lucidia-core/lucidia_core/api.py

"""FastAPI wrapper for Lucidia reasoning engines.

Provides REST endpoints for each specialized agent:
- /physicist - Physics simulations and energy modeling
- /mathematician - Mathematical computations and proofs
- /chemist - Chemical analysis and reactions
- /geologist - Geological analysis and terrain modeling
- /analyst - Data analysis and insights
- /architect - System design and blueprints
"""

from __future__ import annotations

import sys
from pathlib import Path
from typing import Any, Dict, List, Optional

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Add parent to path for agent imports
sys.path.insert(0, str(Path(__file__).parent.parent))

app = FastAPI(
    title="Lucidia API",
    description="AI reasoning engines for specialized domains",
    version="0.1.0",
    docs_url="/docs",
    redoc_url="/redoc",
)


# Request/Response models
class AgentRequest(BaseModel):
    """Generic request for agent invocation."""
    query: str
    context: Optional[Dict[str, Any]] = None
    parameters: Optional[Dict[str, Any]] = None


class AgentResponse(BaseModel):
    """Generic response from agent."""
    agent: str
    result: Any
    artifacts: Optional[List[str]] = None
    journal_entry: Optional[str] = None


class HealthResponse(BaseModel):
    """Health check response."""
    status: str
    agents: List[str]
    version: str


# Health endpoint
@app.get("/health", response_model=HealthResponse)
async def health():
    """Check API health and list available agents."""
    return HealthResponse(
        status="healthy",
        agents=[
            "physicist",
            "mathematician",
            "chemist",
            "geologist",
            "analyst",
            "architect",
            "engineer",
            "painter",
            "poet",
            "speaker",
        ],
        version="0.1.0",
    )


# Physicist endpoints
@app.post("/physicist/analyze", response_model=AgentResponse)
async def physicist_analyze(request: AgentRequest):
    """Analyze physics-related query using the Physicist agent."""
    try:
        from physicist import PhysicistSeed
        return AgentResponse(
            agent="physicist",
            result={"query": request.query, "status": "analysis_pending"},
            journal_entry="Physicist received analysis request.",
        )
    except ImportError as e:
        raise HTTPException(status_code=500, detail=f"Physicist module error: {e}")


@app.post("/physicist/energy-flow", response_model=AgentResponse)
async def physicist_energy_flow(request: AgentRequest):
    """Model energy flows in a system."""
    return AgentResponse(
        agent="physicist",
        result={"flow_model": "pending", "query": request.query},
        journal_entry="Modeling energy flows...",
    )


# Mathematician endpoints
@app.post("/mathematician/compute", response_model=AgentResponse)
async def mathematician_compute(request: AgentRequest):
    """Perform mathematical computation."""
    try:
        import sympy as sp
        # Parse and evaluate expression if safe
        result = {"expression": request.query, "computed": True}
        return AgentResponse(
            agent="mathematician",
            result=result,
            journal_entry="Mathematician processed computation.",
        )
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Computation error: {e}")


@app.post("/mathematician/prove", response_model=AgentResponse)
async def mathematician_prove(request: AgentRequest):
    """Attempt to prove a mathematical statement."""
    return AgentResponse(
        agent="mathematician",
        result={"statement": request.query, "proof_status": "pending"},
        journal_entry="Mathematician examining proof...",
    )


# Chemist endpoints
@app.post("/chemist/analyze", response_model=AgentResponse)
async def chemist_analyze(request: AgentRequest):
    """Analyze chemical compound or reaction."""
    return AgentResponse(
        agent="chemist",
        result={"compound": request.query, "analysis": "pending"},
        journal_entry="Chemist analyzing molecular structure...",
    )


# Geologist endpoints
@app.post("/geologist/terrain", response_model=AgentResponse)
async def geologist_terrain(request: AgentRequest):
    """Analyze geological terrain data."""
    return AgentResponse(
        agent="geologist",
        result={"terrain": request.query, "analysis": "pending"},
        journal_entry="Geologist surveying terrain...",
    )


# Analyst endpoints
@app.post("/analyst/insights", response_model=AgentResponse)
async def analyst_insights(request: AgentRequest):
    """Generate insights from data."""
    return AgentResponse(
        agent="analyst",
        result={"data": request.query, "insights": []},
        journal_entry="Analyst processing data...",
    )


# Architect endpoints
@app.post("/architect/design", response_model=AgentResponse)
async def architect_design(request: AgentRequest):
    """Generate system design blueprint."""
    return AgentResponse(
        agent="architect",
        result={"requirements": request.query, "blueprint": "pending"},
        journal_entry="Architect drafting design...",
    )


def run():
    """Run the API server."""
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)


if __name__ == "__main__":
    run()