Quesaco ?

"""Security gateway worker - handles auth and forwards to API worker."""
import logging
import json
import js
from workers import WorkerEntrypoint, Response


ALLOWED_ORIGINS = [
    "",
    "",
    "",
    "",
]

CORS_HEADERS = {
    "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
    "Access-Control-Allow-Headers": "Content-Type, API_KEY_TOKEN",
}

# Rate limit config
RATE_LIMIT_MAX = int
RATE_LIMIT_WINDOW = int


def get_timestamp():
    """Retourne le timestamp actuel en secondes."""
    return int(js.Date.now() / 1000)


def error_response(detail: str, status: int = 400, origin: str = None):
    headers = {"Content-Type": "application/json"}
    if origin and origin in ALLOWED_ORIGINS:
        headers["Access-Control-Allow-Origin"] = origin
    return Response(
        json.dumps({"detail": detail}),
        status=status,
        headers=headers
    )


def add_cors_headers(response: Response, origin: str) -> Response:
    headers = {**dict(response.headers), **CORS_HEADERS}
    if origin in ALLOWED_ORIGINS:
        headers["Access-Control-Allow-Origin"] = origin
    return Response(
        response.body,
        status=response.status,
        headers=headers
    )


class Default(WorkerEntrypoint):
    """Gateway Worker - Auth and forward."""

    async def _check_rate_limit(self, ip: str) -> bool:
        """Retourne True si rate limit dépassé."""
        key = f"ratelimit:{ip}"
        now = get_timestamp()
        window_start = now - RATE_LIMIT_WINDOW

        try:
            data = await self.env.KV.get(key)
            if data:
                record = json.loads(data)
                requests = [ts for ts in record["requests"] if ts > window_start]
            else:
                requests = []

            if len(requests) >= RATE_LIMIT_MAX:
                return True

            requests.append(now)
            await self.env.KV.put(
                key,
                json.dumps({"requests": requests}),
                expiration_ttl=RATE_LIMIT_WINDOW
            )
            return False

        except Exception as e:
            logging.error(f"Rate limit error: {e}")
            return False

    async def fetch(self, request):
        url = request.url
        method = request.method
        path = "/" + url.split("/", 3)[-1]
        origin = request.headers.get("Origin")
        client_ip = request.headers.get("CF-Connecting-IP", "unknown")

        # Handle CORS preflight
        if method == "OPTIONS":
            headers = {**CORS_HEADERS}
            if origin in ALLOWED_ORIGINS:
                headers["Access-Control-Allow-Origin"] = origin
            return Response("", headers=headers)

        # Route PUBLIQUE avec rate limit
        if path.startswith("/le/path/qui/va/bien"):
            if origin not in ALLOWED_ORIGINS:
                return error_response("Forbidden", 403, origin)

            if await self._check_rate_limit(client_ip):
                return error_response("Rate limit exceeded. Try again later.", 429, origin)

            response = await self.env.AI_WORKER.fetch(request)
            return add_cors_headers(response, origin)

        # Health endpoint
        if path.startswith("/le/path/qui/va/bien"):
            auth_error = await self._verify_headers(
                request=request,
                header_name="header spécifique pour le health check",
                secret=self.env.LE_TOKEN_QUI_VA_BIEN,
            )
            if auth_error:
                return auth_error

        # Other endpoints need token
        else:
            auth_error = await self._verify_headers(
                request=request,
                header_name="X-API-Token",
                secret=self.env.API_KEY_TOKEN,
            )
            if auth_error:
                return auth_error

        # Forward to AI worker
        if path.startswith("/le/path/qui/va/bien"):
            response = await self.env.A_FIRST_WORKER.fetch(request)
            return add_cors_headers(response, origin)

        # Forward to API worker
        response = await self.env.ANOTHER_WORKER.fetch(request)
        return add_cors_headers(response, origin)

    async def _verify_headers(
        self,
        request,
        header_name: str,
        secret: any,
    ) -> Response | None:
        try:
            token = request.headers.get(header_name)
            if not token:
                return error_response("Token not valid", 403)

            secret_binding = secret
            if hasattr(secret_binding, 'get') and callable(secret_binding.get):
                secret_value = await secret_binding.get()
            else:
                secret_value = secret_binding

            if token != secret_value:
                return error_response("Token not valid", 403)

            return None
        except Exception as e:
            logging.error(f"Auth error: {e}")
            return error_response("Authentication error", 500)

from workers import WorkerEntrypoint, Response
import json
import js

class Default(WorkerEntrypoint):
    async def fetch(self, request):
        body = await request.json()
        prompt = body.get("prompt")

        if prompt is None:
            return Response(
                json.dumps({"error": "Bad request"}),
                status=400,
                headers={"Content-Type": "application/json"},
            )

        try:
            result = await self.env.AI.run(
                "@cf/le_bon/model",
                js.JSON.parse(json.dumps({
                    "messages": [
                        {
                            "role": "user",
                            "content": "Le petit prompt qui va bien avec la page qu'on veut summarize."
                        }
                    ],
                    "max_tokens": int
                })),
            )

            # Convertir via JSON.stringify
            result_str = js.JSON.stringify(result)
            result_dict = json.loads(result_str)
            summary = result_dict.get('response', str(result_dict))

            return Response(
                json.dumps({"result": {"summary": summary}}),
                status=200,
                headers={"Content-Type": "application/json"},
            )
        except Exception as e:
            return Response(
                json.dumps({"error": str(e)}),
                status=500,
                headers={"Content-Type": "application/json"},
            )