feat: add aiprovider service foundation

backend/app/api/main.py

@@ -1,5 +1,6 @@
 from fastapi import APIRouter
 from app.api.v1 import (
+    ai,
     auth,
     users,
     datasource_config,
@@ -18,6 +19,7 @@ from app.api.v1 import (
 api_router = APIRouter()
 
 api_router.include_router(auth.router, prefix="/auth", tags=["auth"])
+api_router.include_router(ai.router, prefix="/ai", tags=["ai"])
 api_router.include_router(users.router, prefix="/users", tags=["users"])
 api_router.include_router(
     datasource_config.router, prefix="/datasources", tags=["datasource-config"]

backend/app/api/v1/ai.py

@@ -0,0 +1,39 @@
+from uuid import uuid4
+
+from fastapi import APIRouter, Depends, Request, Response
+
+from app.core.security import get_current_user
+from app.models.user import User
+from app.schemas.ai import (
+    AIProviderStatusResponse,
+    SituationalAnalysisRequest,
+    SituationalAnalysisResponse,
+)
+from app.services.ai_client import AIProviderClient, get_ai_provider_client
+
+router = APIRouter()
+
+
+@router.get("/provider/status", response_model=AIProviderStatusResponse)
+async def get_ai_provider_status(
+    request: Request,
+    response: Response,
+    current_user: User = Depends(get_current_user),
+    provider_client: AIProviderClient = Depends(get_ai_provider_client),
+):
+    request_id = request.headers.get("X-Request-ID") or str(uuid4())
+    response.headers["X-Request-ID"] = request_id
+    return await provider_client.get_status(request_id=request_id)
+
+
+@router.post("/situational-awareness/analyze", response_model=SituationalAnalysisResponse)
+async def analyze_situational_awareness(
+    payload: SituationalAnalysisRequest,
+    request: Request,
+    response: Response,
+    current_user: User = Depends(get_current_user),
+    provider_client: AIProviderClient = Depends(get_ai_provider_client),
+):
+    request_id = request.headers.get("X-Request-ID") or str(uuid4())
+    response.headers["X-Request-ID"] = request_id
+    return await provider_client.analyze(payload, request_id=request_id)

backend/app/core/config.py

@@ -37,6 +37,11 @@ class Settings(BaseSettings):
     SPACETRACK_USERNAME: str = ""
     SPACETRACK_PASSWORD: str = ""
 
+    AI_PROVIDER_SERVICE_URL: str = "http://localhost:8010"
+    AI_PROVIDER_SERVICE_TOKEN: str = ""
+    AI_PROVIDER_TIMEOUT_SECONDS: int = 60
+    AI_PROVIDER_RETRY_ATTEMPTS: int = 2
+
     @property
     def REDIS_URL(self) -> str:
         return os.getenv(
@@ -46,6 +51,7 @@ class Settings(BaseSettings):
     class Config:
         env_file = Path(__file__).parent.parent.parent / ".env"
         case_sensitive = True
+        extra = "ignore"
 
 
 @lru_cache()

backend/app/schemas/ai.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class SituationalAnalysisRequest(BaseModel):
+    title: str = Field(..., min_length=1, max_length=200)
+    objective: str = Field(..., min_length=1, max_length=1000)
+    context: dict[str, Any] = Field(default_factory=dict)
+    observations: list[str] = Field(default_factory=list)
+    constraints: list[str] = Field(default_factory=list)
+    preferred_model: str | None = Field(default=None, max_length=200)
+
+
+class SituationalAnalysisResponse(BaseModel):
+    provider: str
+    model: str
+    content: str
+    raw_response: dict[str, Any] = Field(default_factory=dict)
+
+
+class AIProviderStatusResponse(BaseModel):
+    provider: str
+    enabled: bool
+    configured: bool
+    model: str | None = None
+    base_url: str | None = None

backend/app/services/ai_client.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import asyncio
+
+import httpx
+from fastapi import HTTPException, status
+
+from app.core.config import settings
+from app.schemas.ai import (
+    AIProviderStatusResponse,
+    SituationalAnalysisRequest,
+    SituationalAnalysisResponse,
+)
+
+
+class AIProviderClient:
+    def __init__(self) -> None:
+        self.service_url = settings.AI_PROVIDER_SERVICE_URL.rstrip("/")
+        self.service_token = settings.AI_PROVIDER_SERVICE_TOKEN
+        self.timeout = settings.AI_PROVIDER_TIMEOUT_SECONDS
+        self.retry_attempts = max(settings.AI_PROVIDER_RETRY_ATTEMPTS, 1)
+
+    def _headers(self, request_id: str | None = None) -> dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.service_token:
+            headers["X-Provider-Token"] = self.service_token
+        if request_id:
+            headers["X-Request-ID"] = request_id
+        return headers
+
+    async def get_status(self, request_id: str | None = None) -> AIProviderStatusResponse:
+        if not self.service_url:
+            return AIProviderStatusResponse(
+                provider="unconfigured",
+                enabled=False,
+                configured=False,
+                model=None,
+                base_url=None,
+            )
+
+        data = await self._request("GET", "/v1/provider/status", request_id=request_id)
+        return AIProviderStatusResponse.model_validate(data)
+
+    async def analyze(
+        self,
+        payload: SituationalAnalysisRequest,
+        request_id: str | None = None,
+    ) -> SituationalAnalysisResponse:
+        if not self.service_url:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="AI provider service URL is not configured.",
+            )
+
+        data = await self._request(
+            "POST",
+            "/v1/analyze",
+            json=payload.model_dump(),
+            request_id=request_id,
+        )
+        return SituationalAnalysisResponse.model_validate(data)
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        json: dict | None = None,
+        request_id: str | None = None,
+    ) -> dict:
+        last_error: Exception | None = None
+        for attempt in range(1, self.retry_attempts + 1):
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout) as client:
+                    response = await client.request(
+                        method,
+                        f"{self.service_url}{path}",
+                        headers=self._headers(request_id),
+                        json=json,
+                    )
+                    response.raise_for_status()
+                    return response.json()
+            except httpx.HTTPStatusError as exc:
+                last_error = exc
+                if attempt < self.retry_attempts and exc.response.status_code >= 500:
+                    await asyncio.sleep(0.3 * attempt)
+                    continue
+                detail = exc.response.text or "AI provider service returned an error"
+                raise HTTPException(
+                    status_code=status.HTTP_502_BAD_GATEWAY,
+                    detail=f"AI provider service request failed: {detail}",
+                ) from exc
+            except httpx.HTTPError as exc:
+                last_error = exc
+                if attempt < self.retry_attempts:
+                    await asyncio.sleep(0.3 * attempt)
+                    continue
+                raise HTTPException(
+                    status_code=status.HTTP_502_BAD_GATEWAY,
+                    detail=f"Failed to reach AI provider service: {exc}",
+                ) from exc
+
+        raise HTTPException(
+            status_code=status.HTTP_502_BAD_GATEWAY,
+            detail=f"AI provider service request failed: {last_error}",
+        )
+
+
+def get_ai_provider_client() -> AIProviderClient:
+    return AIProviderClient()

backend/app/services/system_control.py

@@ -19,6 +19,10 @@ ALLOWED_ACTIONS: dict[str, dict[str, Any]] = {
         "command": ["./planet.sh", "restart", "-b"],
         "recovery_mode": "backend",
     },
+    "restart-ai-provider": {
+        "command": ["./planet.sh", "restart", "-a"],
+        "recovery_mode": "ai-provider",
+    },
     "restart-database": {
         "command": ["./planet.sh", "restart", "-d"],
         "recovery_mode": "database",