resume-agent/backend/app/main.py

from __future__ import annotations

import logging
import os
from pathlib import Path
from typing import Any
from uuid import uuid4

from fastapi import FastAPI, Header, HTTPException, Response, UploadFile, status
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse

from .agent import ResumeAgent
from .experience_optimizer import ExperienceOptimizer, build_experience_optimizer
from .target_position_suggester import TargetPositionSuggester, build_target_position_suggester
from .resume_expansion import build_expander
from .profile_summary import ProfileSummaryGenerator, build_profile_summary_generator
from .offerpai_auth import OfferPaiAuthClient, OfferPaiIdentityProvider
from .offerpai_resume import OfferPaiResumeClient, OfferPaiResumeProvider
from .database import Database
from .postgres_database import PostgresDatabase
from .fsm import FSMError
from .builder_sse import stream_builder_message
from .llm_services import OpenAICompatibleStructuredClient, build_services
from .models import (
    ActionResponse,
    ComponentEventRequest,
    CreateResumeRequest,
    CreateResumeResponse,
    CreateSessionRequest,
    ErrorDetail,
    MessageRequest,
    Stage,
    TimelineResponse,
)
from .resume_routes import register_resume_routes
from .resume_import_routes import register_resume_import_routes
from .resume_import_service import ResumeImportService, RuleBasedResumeImportParser
from .import_parser import OpenAIResumeImportParser
from .rate_limit import SlidingWindowRateLimiter
from .services import (
    EntryExpander,
    ExperienceExtractor,
    ResumeRewriter,
    RuleBasedEntryExpander,
)
from .settings import Settings, load_settings
from .skill_suggester import SkillSuggester, build_skill_suggester


API_PREFIX = "/ai-api/resume-agent"


def _bearer_token(authorization: str | None) -> str | None:
    if authorization is None:
        return None
    scheme, separator, value = authorization.partition(" ")
    token = value.strip()
    if separator != " " or scheme.lower() != "bearer" or not token:
        raise FSMError(
            "external_auth_header_invalid",
            "登录凭证格式无效，请重新从 OfferPai 进入。",
            status_code=401,
        )
    return token


def create_app(
    *,
    database_path: str | Path | None = None,
    extractor: ExperienceExtractor | None = None,
    rewriter: ResumeRewriter | None = None,
    expander: EntryExpander | None = None,
    skill_suggester: SkillSuggester | None = None,
    experience_optimizer: ExperienceOptimizer | None = None,
    target_position_suggester: TargetPositionSuggester | None = None,
    cors_origins: list[str] | None = None,
    settings: Settings | None = None,
    openai_client: Any | None = None,
    resume_import_service: ResumeImportService | None = None,
    profile_summary_generator: ProfileSummaryGenerator | None = None,
    offerpai_identity_provider: OfferPaiIdentityProvider | None = None,
    offerpai_resume_provider: OfferPaiResumeProvider | None = None,
) -> FastAPI:
    resolved_settings = settings or load_settings()
    if database_path is not None:
        database = Database(database_path)
    else:
        if not resolved_settings.database_url:
            raise ValueError("DATABASE_URL is required; pass database_path explicitly for SQLite tests")
        database = PostgresDatabase(
            resolved_settings.database_url,
            schema=os.getenv("RESUME_AGENT_DATABASE_SCHEMA", "resume_agent"),
        )
    database.initialize()
    if extractor is None or rewriter is None:
        default_extractor, default_rewriter = build_services(
            resolved_settings, openai_client
        )
        extractor = extractor or default_extractor
        rewriter = rewriter or default_rewriter
    configured_default_tier = os.environ.get("RESUME_AGENT_DEFAULT_TIER", "free").strip().lower()
    if configured_default_tier != "free":
        logging.getLogger(__name__).warning(
            "TIER BACKDOOR ACTIVE: all sessions default to %s",
            configured_default_tier,
        )
    if expander is None:
        expander = build_expander(resolved_settings, openai_client)
    skill_suggester = skill_suggester or build_skill_suggester(resolved_settings, openai_client)
    experience_optimizer = experience_optimizer or build_experience_optimizer(
        resolved_settings, openai_client
    )


    target_position_suggester = target_position_suggester or build_target_position_suggester(
        resolved_settings, openai_client
    )
    profile_summary_generator = profile_summary_generator or build_profile_summary_generator(
        resolved_settings, openai_client
    )
    offerpai_identity_provider = offerpai_identity_provider or OfferPaiAuthClient(
        resolved_settings.offerpai_auth_base_url,
        timeout_seconds=resolved_settings.offerpai_auth_timeout_seconds,
    )
    offerpai_resume_provider = offerpai_resume_provider or OfferPaiResumeClient(
        resolved_settings.offerpai_resume_api_base_url,
        timeout_seconds=resolved_settings.offerpai_resume_timeout_seconds,
    )
    agent = ResumeAgent(
        database=database,
        extractor=extractor,
        rewriter=rewriter,
        expander=expander,
        skill_suggester=skill_suggester,
        experience_optimizer=experience_optimizer,
        target_position_suggester=target_position_suggester,
        profile_summary_generator=profile_summary_generator,
        offerpai_identity_provider=offerpai_identity_provider,
        offerpai_resume_provider=offerpai_resume_provider,
    )
    application = FastAPI(
        title="Resume Agent MVP",
        version="0.1.0",
        description="SQLite-backed resume workflow implemented as an explicit finite-state machine.",
    )
    origins = cors_origins or _cors_origins_from_environment()
    application.add_middleware(
        CORSMiddleware,
        allow_origins=origins,
        allow_credentials="*" not in origins,
        allow_methods=["GET", "POST", "PATCH", "DELETE", "OPTIONS"],
        allow_headers=["*"],
    )
    application.state.database = database
    application.state.resume_agent = agent
    application.state.offerpai_identity_provider = offerpai_identity_provider
    application.state.offerpai_resume_provider = offerpai_resume_provider
    if resume_import_service is None:
        import_fallback = RuleBasedResumeImportParser()
        import_parser = import_fallback
        if resolved_settings.use_openai:
            import_parser = OpenAIResumeImportParser(
                completion=OpenAICompatibleStructuredClient(resolved_settings, openai_client),
                fallback=import_fallback,
            )
        resume_import_service = ResumeImportService(
            storage_root=Path(__file__).resolve().parent.parent / "data" / "resume_imports",
            parser=import_parser,
        )
    application.state.resume_import_service = resume_import_service
    application.state.light_opt_limiter = SlidingWindowRateLimiter(
        limit=resolved_settings.light_opt_rate_limit,
        window_seconds=resolved_settings.light_opt_rate_window_seconds,
    )

    def authorize_session_request(
        session_id: str, authorization: str | None
    ) -> str | None:
        external_token = _bearer_token(authorization)
        requires_external_auth = resolved_settings.offerpai_auth_required
        if not requires_external_auth and external_token is None:
            existing_session = agent.database.get_session(session_id)
            external_account = (
                existing_session["profile"].get("external_account")
                if existing_session is not None
                else None
            )
            requires_external_auth = isinstance(external_account, dict)
        if requires_external_auth and external_token is None:
            raise FSMError(
                "external_auth_required",
                "缺少 OfferPai 登录凭证，请从 OfferPai 重新进入。",
                status_code=401,
            )
        if external_token is not None:
            agent.authorize_session(session_id, external_token)
        return external_token

    @application.exception_handler(FSMError)
    async def handle_fsm_error(_request: Any, exc: FSMError) -> JSONResponse:
        trace_id = f"trace_{uuid4().hex}"
        detail = ErrorDetail(
            code=exc.code,
            message=exc.message,
            missing_fields=exc.missing_fields,
            trace_id=trace_id,
        )
        return JSONResponse(
            status_code=exc.status_code,
            content={"error": detail.model_dump(mode="json"), "trace_id": trace_id},
        )

    @application.get("/health", tags=["system"])
    def health() -> dict[str, str]:
        return {"status": "ok"}

    @application.post(
        f"{API_PREFIX}/sessions",
        response_model=TimelineResponse,
        status_code=status.HTTP_201_CREATED,
        tags=["resume-agent"],
    )
    def create_session(
        request: CreateSessionRequest | None = None,
        authorization: str | None = Header(default=None),
    ) -> TimelineResponse:
        external_token = _bearer_token(authorization)
        if resolved_settings.offerpai_auth_required and external_token is None:
            raise FSMError(
                "external_auth_required",
                "缺少 OfferPai 登录凭证，请从 OfferPai 重新进入。",
                status_code=401,
            )
        response = agent.create_session(
            request or CreateSessionRequest(),
            external_token=external_token,
        )
        if (
            external_token is not None
            and response.stage == Stage.MINIMUM_READY
            and response.resume_id is None
        ):
            agent.mutate_with_offerpai_sync(
                response.session_id,
                external_token,
                lambda: agent.create_resume(
                    response.session_id, CreateResumeRequest()
                ),
            )
            response = agent.timeline(response.session_id)
        if external_token is not None:
            agent.reconcile_resume_with_offerpai(
                response.session_id, external_token
            )
            response = agent.timeline(response.session_id)
        return response

    @application.get(
        f"{API_PREFIX}/sessions/{{session_id}}/timeline",
        response_model=TimelineResponse,
        tags=["resume-agent"],
    )
    def get_timeline(
        session_id: str,
        authorization: str | None = Header(default=None),
    ) -> TimelineResponse:
        external_token = authorize_session_request(session_id, authorization)
        if external_token is not None:
            agent.reconcile_resume_with_offerpai(session_id, external_token)
        return agent.timeline(session_id)

    @application.post(
        f"{API_PREFIX}/sessions/{{session_id}}/component-events",
        response_model=ActionResponse,
        tags=["resume-agent"],
    )
    def post_component_event(
        session_id: str,
        request: ComponentEventRequest,
        authorization: str | None = Header(default=None),
    ) -> ActionResponse:
        external_token = authorize_session_request(session_id, authorization)

        def mutate() -> ActionResponse:
            response = agent.component_event(session_id, request)
            if (
                external_token is not None
                and response.stage == Stage.MINIMUM_READY
                and response.resume_id is None
            ):
                response = agent.create_resume(session_id, CreateResumeRequest())
            return response

        if external_token is None:
            return mutate()
        return agent.mutate_with_offerpai_sync(
            session_id,
            external_token,
            mutate,
        )

    @application.post(
        f"{API_PREFIX}/sessions/{{session_id}}/messages",
        response_model=ActionResponse,
        tags=["resume-agent"],
    )
    def post_message(
        session_id: str,
        request: MessageRequest,
        authorization: str | None = Header(default=None),
    ) -> ActionResponse:
        external_token = authorize_session_request(session_id, authorization)
        if external_token is None:
            return agent.add_message(session_id, request)
        return agent.mutate_with_offerpai_sync(
            session_id,
            external_token,
            lambda: agent.add_message(session_id, request),
        )

    @application.post(
        f"{API_PREFIX}/sessions/{{session_id}}/messages/stream",
        tags=["resume-agent"],
    )
    def post_message_stream(
        session_id: str,
        request: MessageRequest,
        authorization: str | None = Header(default=None),
    ):
        external_token = authorize_session_request(session_id, authorization)

        def add_and_sync() -> ActionResponse:
            if external_token is None:
                return agent.add_message(session_id, request)
            return agent.mutate_with_offerpai_sync(
                session_id,
                external_token,
                lambda: agent.add_message(session_id, request),
            )

        return stream_builder_message(add_and_sync)
    @application.post(
        f"{API_PREFIX}/sessions/{{session_id}}/create",
        response_model=CreateResumeResponse,
        tags=["resume-agent"],
    )
    def create_resume(
        session_id: str,
        request: CreateResumeRequest | None = None,
        authorization: str | None = Header(default=None),
    ) -> CreateResumeResponse:
        external_token = authorize_session_request(session_id, authorization)
        create_request = request or CreateResumeRequest()
        if external_token is None:
            return agent.create_resume(session_id, create_request)
        return agent.mutate_with_offerpai_sync(
            session_id,
            external_token,
            lambda: agent.create_resume(session_id, create_request),
        )

    register_resume_routes(
        application,
        agent,
        API_PREFIX,
        authorize_session_request=authorize_session_request,
    )
    register_resume_import_routes(
        application,
        agent,
        application.state.resume_import_service,
        API_PREFIX,
        authorize_session_request=authorize_session_request,
    )

    @application.delete(
        f"{API_PREFIX}/sessions/{{session_id}}",
        status_code=status.HTTP_204_NO_CONTENT,
        tags=["resume-agent"],
    )
    def delete_session(
        session_id: str,
        authorization: str | None = Header(default=None),
    ) -> Response:
        external_token = authorize_session_request(session_id, authorization)
        agent.delete_session(session_id, external_token=external_token)
        return Response(status_code=status.HTTP_204_NO_CONTENT)

    return application


def _cors_origins_from_environment() -> list[str]:
    configured = os.getenv("RESUME_AGENT_CORS_ORIGINS")
    if configured:
        return [origin.strip() for origin in configured.split(",") if origin.strip()]
    return ["http://localhost:5173", "http://127.0.0.1:5173"]


app = create_app()