from __future__ import annotations import logging from collections.abc import AsyncIterator from contextlib import asynccontextmanager import httpx from fastapi import FastAPI, HTTPException, Request, Response from fastapi.exceptions import RequestValidationError from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import JSONResponse from app.config import Settings from app.knowledge import system_prompt from app.memory import ( InvalidMemorySession, MemoryConsentRequired, MemoryLimitReached, MemoryRecord, MemoryStore, SensitiveMemoryRejected, extract_explicit_memory, ) from app.models import ( FuugiRequest, FuugiResponse, MemoryConsentRequest, MemoryEvent, MemoryItem, MemoryListResponse, ) from app.openrouter import OpenRouterClient, OpenRouterNotConfigured, OpenRouterUnavailable from app.worker import WorkerClient, WorkerNotConfigured, WorkerUnavailable from app.research import ResearchStore, ResearchWriteError, classify_research from app.security import ( BodySizeLimitMiddleware, SlidingWindowRateLimiter, client_identity, request_messages, ) logger = logging.getLogger(__name__) def create_app( settings: Settings | None = None, transport: httpx.AsyncBaseTransport | None = None, worker_transport: httpx.AsyncBaseTransport | None = None, ) -> FastAPI: active_settings = settings or Settings.from_env() memory_store = ( MemoryStore( database_path=active_settings.memory_database_path, pepper=active_settings.memory_session_pepper, retention_days=active_settings.memory_retention_days, max_items=active_settings.memory_max_items, max_item_characters=active_settings.memory_max_item_characters, max_context_characters=active_settings.memory_max_context_characters, ) if active_settings.memory_enabled else None ) research_store = ( ResearchStore( database_path=active_settings.market_research_database_path, retention_days=active_settings.market_research_retention_days, ) if active_settings.market_research_enabled else None ) @asynccontextmanager async def lifespan(application: FastAPI) -> AsyncIterator[None]: client = OpenRouterClient(active_settings, transport=transport) worker = WorkerClient(active_settings, transport=worker_transport) application.state.openrouter = client application.state.worker = worker try: yield finally: await worker.close() await client.close() application = FastAPI( title="Fuugi Companion API", version="1.0.0", docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan, ) application.state.settings = active_settings application.state.memory = memory_store application.state.research = research_store application.state.rate_limiter = SlidingWindowRateLimiter( active_settings.rate_limit_requests, active_settings.rate_limit_window_seconds, ) application.add_middleware( CORSMiddleware, allow_origins=list(active_settings.allowed_origins), allow_credentials=False, allow_methods=["GET", "POST", "DELETE", "OPTIONS"], allow_headers=["Accept", "Content-Type", "X-Fuugi-Session"], max_age=600, ) application.add_middleware( BodySizeLimitMiddleware, max_body_bytes=active_settings.max_body_bytes, ) @application.exception_handler(RequestValidationError) async def invalid_request(_request: Request, _error: RequestValidationError) -> JSONResponse: return JSONResponse({"detail": "Invalid request."}, status_code=400) async def enforce_rate_limit(request: Request) -> None: limiter: SlidingWindowRateLimiter = request.app.state.rate_limiter allowed, retry_after = await limiter.check(client_identity(request, active_settings)) if not allowed: raise HTTPException( status_code=429, detail="Too many requests.", headers={"Retry-After": str(retry_after)}, ) @application.get("/health") async def health() -> dict[str, str | bool]: worker_on = bool( active_settings.fuugi_worker_url and active_settings.fuugi_worker_token ) return { "status": "ok", "service": "fuugi-api", "source": "fuugi-worker" if worker_on else "openrouter", "model": "fuugi-worker" if worker_on else active_settings.primary_model, "upstream_configured": bool(active_settings.openrouter_api_key), "worker_configured": worker_on, } def memory_access(request: Request) -> tuple[MemoryStore, str]: store: MemoryStore | None = request.app.state.memory if store is None: raise HTTPException(status_code=404, detail="Memory is not enabled.") token = request.headers.get("x-fuugi-session", "").strip() if not token: raise HTTPException(status_code=400, detail="Memory session is required.") return store, token def memory_items(records: list[MemoryRecord]) -> list[MemoryItem]: return [ MemoryItem( id=record.id, content=record.content, created_at=record.created_at, expires_at=record.expires_at, ) for record in records ] @application.get( "/api/fuugi", response_model=FuugiResponse, response_model_exclude_none=True ) async def fuugi_info(request: Request) -> FuugiResponse: await enforce_rate_limit(request) return FuugiResponse( content="Fuugi companion API is online. POST the widget JSON payload to this endpoint.", source="api", model=active_settings.primary_model, ) @application.options("/api/fuugi", status_code=204) async def fuugi_options() -> Response: return Response(status_code=204) @application.post("/api/fuugi/memory-consent", response_model=MemoryListResponse) async def memory_consent( payload: MemoryConsentRequest, request: Request ) -> MemoryListResponse: await enforce_rate_limit(request) store, token = memory_access(request) try: enabled = await store.set_consent(token, payload.enabled) _, records = await store.list(token) except InvalidMemorySession as error: raise HTTPException(status_code=400, detail="Invalid memory session.") from error return MemoryListResponse( enabled=enabled, memories=memory_items(records), ) @application.get("/api/fuugi/memories", response_model=MemoryListResponse) async def list_memories(request: Request) -> MemoryListResponse: await enforce_rate_limit(request) store, token = memory_access(request) try: enabled, records = await store.list(token) except InvalidMemorySession as error: raise HTTPException(status_code=400, detail="Invalid memory session.") from error return MemoryListResponse( enabled=enabled, memories=memory_items(records), ) @application.delete("/api/fuugi/memories", response_model=MemoryListResponse) async def clear_memories(request: Request) -> MemoryListResponse: await enforce_rate_limit(request) store, token = memory_access(request) try: await store.clear(token) enabled, _ = await store.list(token) except InvalidMemorySession as error: raise HTTPException(status_code=400, detail="Invalid memory session.") from error return MemoryListResponse(enabled=enabled, memories=[]) @application.delete("/api/fuugi/memories/{memory_id}", status_code=204) async def delete_memory(memory_id: str, request: Request) -> Response: await enforce_rate_limit(request) store, token = memory_access(request) try: deleted = await store.delete(token, memory_id) except InvalidMemorySession as error: raise HTTPException(status_code=400, detail="Invalid memory reference.") from error if not deleted: raise HTTPException(status_code=404, detail="Memory not found.") return Response(status_code=204) @application.post( "/api/fuugi", response_model=FuugiResponse, response_model_exclude_none=True ) async def fuugi_chat(payload: FuugiRequest, request: Request) -> FuugiResponse: await enforce_rate_limit(request) store: MemoryStore | None = request.app.state.memory token = request.headers.get("x-fuugi-session", "").strip() explicit_memory = extract_explicit_memory(payload.message) if explicit_memory is not None: if store is None: return FuugiResponse( content="Der Lernspeicher ist auf diesem Server nicht aktiviert.", source="memory", model="local-memory-v1", memory_event=MemoryEvent(status="unavailable"), ) if not token: return FuugiResponse( content=( "Aktiviere zuerst den Lernspeicher im Chat, damit ich das speichern darf." ), source="memory", model="local-memory-v1", memory_event=MemoryEvent(status="consent_required"), ) try: record = await store.add(token, explicit_memory) except MemoryConsentRequired: return FuugiResponse( content=( "Aktiviere zuerst den Lernspeicher im Chat, damit ich das speichern darf." ), source="memory", model="local-memory-v1", memory_event=MemoryEvent(status="consent_required"), ) except (MemoryLimitReached, SensitiveMemoryRejected): return FuugiResponse( content=( "Das speichere ich nicht. Nutze kurze, nicht sensible Angaben und keine " "Passwörter, Schlüssel oder Zahlungsdaten." ), source="memory", model="local-memory-v1", memory_event=MemoryEvent(status="rejected"), ) except InvalidMemorySession as error: raise HTTPException(status_code=400, detail="Invalid memory session.") from error return FuugiResponse( content="Gemerkt. Du kannst diese Erinnerung jederzeit ansehen oder löschen.", source="memory", model="local-memory-v1", memory_event=MemoryEvent(status="saved", id=record.id), ) memories: list[str] = [] if store is not None and token: try: memories = await store.context(token) except InvalidMemorySession as error: raise HTTPException(status_code=400, detail="Invalid memory session.") from error try: messages = request_messages(payload, active_settings, system_prompt(), memories) except ValueError as error: raise HTTPException(status_code=400, detail="Invalid request.") from error worker: WorkerClient = request.app.state.worker completion = None source = "openrouter" if worker.configured: try: completion = await worker.complete(messages) source = "fuugi-worker" except WorkerNotConfigured: completion = None except WorkerUnavailable: logger.warning("Fuugi worker unavailable; trying OpenRouter fallback.") if completion is None: client: OpenRouterClient = request.app.state.openrouter try: completion = await client.complete(messages) source = "openrouter" except OpenRouterNotConfigured as error: raise HTTPException( status_code=503, detail="Service temporarily unavailable." ) from error except OpenRouterUnavailable as error: raise HTTPException( status_code=502, detail="Upstream service temporarily unavailable." ) from error research: ResearchStore | None = request.app.state.research if research is not None: research_text = payload.message if not research_text: research_text = next( ( item.content for item in reversed(payload.messages) if item.role == "user" ), "", ) if research_text: topic, intent = classify_research(research_text) try: await research.increment(topic, intent) except ResearchWriteError: logger.warning("Anonymous research counter update failed.") return FuugiResponse( content=completion.content, source=source, model=completion.model, ) return application app = create_app()