Add app\api\v1\proposai.py

app//api//v1//proposai.py

@@ -0,0 +1,136 @@
+# app/api/v1/proposai.py
+import asyncio
+import hashlib
+import time
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func
+
+from app.api import deps
+from app.schemas.proposal import (
+    ProposalCreate,
+    ProposalResponse,
+    ProposalUpdate,
+    SpecificAimsRequest,
+    SpecificAimsResponse,
+    SeedPaperRef
+)
+from app.services.proposai.engine import ProposAIEngine
+from app.tasks.proposai_generation import trigger_proposai_task
+from app.models.proposal import Proposal, ProposalStatus, FunderCache
+
+router = APIRouter()
+engine = ProposAIEngine()
+
+
+@router.post("/init", response_model=ProposalResponse, status_code=status.HTTP_201_CREATED)
+async def init_strategic_proposal(
+    req: ProposalCreate,
+    db: AsyncSession = Depends(deps.get_db),
+    current_user=Depends(deps.get_current_active_user)
+):
+    """
+    Initiates the strategic proposal development workflow.
+    
+    Performs real-time:
+    1. Gap Detection: Identifies 'white space' in the research landscape.
+    2. Funder Matching: Aligns research question with NIH/global requirements.
+    """
+    start_time = time.time()
+
+    # Prepare Seed Metadata
+    seed_refs = [SeedPaperRef(doi=doi, title="Context Paper") for doi in req.seed_papers_list]
+
+    # Run Instant Intelligence (Gaps and Funders)
+    gaps_task = engine.find_gaps(db, req.research_question, seed_refs)
+    funders_task = engine.match_funders(db, req.research_question, req.target_agencies)
+    
+    gap_analysis, funder_matches = await asyncio.gather(gaps_task, funders_task)
+
+    # Initialize Proposal Record
+    proposal_id = hashlib.sha256(
+        f"{current_user.id}:{req.title}:{time.time()}".encode()
+    ).hexdigest()[:16]
+
+    new_proposal = Proposal(
+        id=proposal_id,
+        user_id=current_user.id,
+        title=req.title,
+        research_question=req.research_question,
+        status=ProposalStatus.DRAFT.value
+    )
+    new_proposal.set_seed_papers_list(req.seed_papers_list)
+    new_proposal.set_foa_matches_list([f.foa_number for f in funder_matches])
+
+    db.add(new_proposal)
+    await db.commit()
+    await db.refresh(new_proposal)
+
+    # Assemble Response
+    return ProposalResponse(
+        **new_proposal.__dict__,
+        gap_analysis=gap_analysis,
+        funder_matches_list=funder_matches,
+        latency_ms=int((time.time() - start_time) * 1000)
+    )
+
+
+@router.post("/generate-aims", status_code=status.HTTP_202_ACCEPTED)
+async def generate_specific_aims(
+    req: SpecificAimsRequest,
+    background_tasks: BackgroundTasks,
+    db: AsyncSession = Depends(deps.get_db),
+    current_user=Depends(deps.get_current_active_user)
+):
+    """
+    Triggers the 5-part research proposal architecture generation.
+    Delegates heavy compute (Specific Aims generation) to background workers.
+    """
+    # Verify proposal ownership
+    result = await db.execute(
+        select(Proposal).where(Proposal.id == req.proposal_id, Proposal.user_id == current_user.id)
+    )
+    proposal = result.scalar_one_or_none()
+    if not proposal:
+        raise HTTPException(status_code=404, detail="Proposal record not found")
+
+    # Enqueue background task
+    background_tasks.add_task(
+        trigger_proposai_task,
+        proposal_id=proposal.id,
+        hypothesis=req.hypothesis,
+        innovation_claim=req.innovation_claim
+    )
+
+    return {"proposal_id": proposal.id, "status": "generating"}
+
+
+@router.get("/{proposal_id}", response_model=ProposalResponse)
+async def get_proposal_status(
+    proposal_id: str,
+    db: AsyncSession = Depends(deps.get_db),
+    current_user=Depends(deps.get_current_active_user)
+):
+    """Retrieves the current state and results of a proposal development job."""
+    result = await db.execute(
+        select(Proposal).where(Proposal.id == proposal_id, Proposal.user_id == current_user.id)
+    )
+    proposal = result.scalar_one_or_none()
+    if not proposal:
+        raise HTTPException(status_code=404, detail="Proposal not found")
+        
+    return proposal
+
+
+@router.get("/health/engine")
+async def get_proposai_health(db: AsyncSession = Depends(deps.get_db)):
+    """System health check for ProposAI caches and model connectivity."""
+    funder_count = await db.scalar(select(func.count()).select_from(FunderCache))
+    return {
+        "status": "ok",
+        "funder_cache_size": funder_count,
+        "compute_mode": "hybrid_delegation",
+        "fallback_available": True
+    }