kairo-code 0.1.0__py3-none-any.whl

kairo/backend/services/llm_service.py

@@ -0,0 +1,186 @@
+import json
+import logging
+from collections.abc import AsyncGenerator
+
+import httpx
+
+from backend.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class LLMService:
+    def __init__(self):
+        self.base_url = settings.VLLM_BASE_URL.rstrip("/")
+        self.lite_base_url = settings.VLLM_LITE_BASE_URL.rstrip("/") if settings.VLLM_LITE_BASE_URL else ""
+        self.model_map = settings.MODEL_MAP
+        headers = {}
+        if settings.VLLM_API_KEY:
+            headers["Authorization"] = f"Bearer {settings.VLLM_API_KEY}"
+        self._client = httpx.AsyncClient(
+            timeout=httpx.Timeout(120.0, connect=10.0),
+            headers=headers,
+        )
+        self._lite_client: httpx.AsyncClient | None = None
+        if self.lite_base_url:
+            self._lite_client = httpx.AsyncClient(
+                timeout=httpx.Timeout(120.0, connect=10.0),
+                headers=headers,
+            )
+        self.primary_healthy = True
+        self.lite_healthy = False
+
+    async def close(self):
+        await self._client.aclose()
+        if self._lite_client:
+            await self._lite_client.aclose()
+
+    def resolve_model(self, name: str) -> str:
+        return self.model_map.get(name, name)
+
+    async def check_primary_health(self) -> bool:
+        try:
+            resp = await self._client.get(f"{self.base_url}/health")
+            healthy = resp.status_code == 200
+            if self.primary_healthy != healthy:
+                logger.info("Primary vLLM health changed: %s → %s", self.primary_healthy, healthy)
+            self.primary_healthy = healthy
+            return healthy
+        except httpx.HTTPError:
+            if self.primary_healthy:
+                logger.warning("Primary vLLM became unhealthy")
+            self.primary_healthy = False
+            return False
+
+    async def check_lite_health(self) -> bool:
+        if not self._lite_client or not self.lite_base_url:
+            self.lite_healthy = False
+            return False
+        try:
+            resp = await self._lite_client.get(f"{self.lite_base_url}/health")
+            healthy = resp.status_code == 200
+            if self.lite_healthy != healthy:
+                logger.info("Lite vLLM health changed: %s → %s", self.lite_healthy, healthy)
+            self.lite_healthy = healthy
+            return healthy
+        except httpx.HTTPError:
+            if self.lite_healthy:
+                logger.warning("Lite vLLM became unhealthy")
+            self.lite_healthy = False
+            return False
+
+    def _select_backend(self, model: str) -> tuple[httpx.AsyncClient, str, str, bool]:
+        """Select the best available backend for the given model.
+        Returns (client, base_url, model_id, is_fallback).
+        """
+        # User explicitly selected nyx-lite
+        if model == "nyx-lite" and self._lite_client and self.lite_base_url:
+            return self._lite_client, self.lite_base_url, "nyx-lite", False
+        # Auto-fallback: nyx requested but primary is down
+        if model == "nyx" and not self.primary_healthy and self._lite_client and self.lite_base_url:
+            return self._lite_client, self.lite_base_url, "nyx-lite", True
+        return self._client, self.base_url, self.resolve_model(model), False
+
+    async def stream_chat(
+        self,
+        messages: list[dict],
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 2048,
+        tools: list[dict] | None = None,
+    ) -> AsyncGenerator[str | dict, None]:
+        client, base_url, model_id, is_fallback = self._select_backend(model)
+
+        if is_fallback:
+            yield {"type": "fallback", "model": "nyx-lite"}
+
+        payload = {
+            "model": model_id,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": True,
+            "stream_options": {"include_usage": True},
+        }
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = "auto"
+
+        logger.info("LLM request: model=%s (resolved=%s fallback=%s) msgs=%d temp=%.1f tools=%s",
+                     model, model_id, is_fallback, len(messages), temperature, bool(tools))
+
+        async with client.stream(
+            "POST",
+            f"{base_url}/v1/chat/completions",
+            json=payload,
+        ) as response:
+            response.raise_for_status()
+            usage_data = None
+            tool_calls_acc: dict[int, dict] = {}
+            async for line in response.aiter_lines():
+                if not line.startswith("data: "):
+                    continue
+                data = line[6:]
+                if data.strip() == "[DONE]":
+                    break
+                try:
+                    chunk = json.loads(data)
+                    # Capture usage from final chunk
+                    if "usage" in chunk and chunk["usage"]:
+                        usage_data = chunk["usage"]
+                    if not chunk.get("choices"):
+                        continue
+                    choice = chunk["choices"][0]
+                    delta = choice.get("delta", {})
+
+                    # Accumulate tool calls across streaming deltas
+                    if "tool_calls" in delta:
+                        for tc in delta["tool_calls"]:
+                            idx = tc["index"]
+                            if idx not in tool_calls_acc:
+                                tool_calls_acc[idx] = {"id": "", "name": "", "arguments": ""}
+                            if tc.get("id"):
+                                tool_calls_acc[idx]["id"] = tc["id"]
+                            func = tc.get("function", {})
+                            if func.get("name"):
+                                tool_calls_acc[idx]["name"] = func["name"]
+                            if func.get("arguments"):
+                                tool_calls_acc[idx]["arguments"] += func["arguments"]
+
+                    content = delta.get("content")
+                    if content:
+                        yield content
+
+                    # Check finish reason for tool calls
+                    finish_reason = choice.get("finish_reason")
+                    if finish_reason == "tool_calls" and tool_calls_acc:
+                        yield {"type": "tool_calls", "calls": list(tool_calls_acc.values())}
+                        tool_calls_acc = {}
+                except (json.JSONDecodeError, KeyError, IndexError):
+                    continue
+            # Yield usage as a special sentinel dict (not a string)
+            if usage_data:
+                yield usage_data  # type: ignore[misc]
+
+    async def check_health(self) -> bool:
+        try:
+            resp = await self._client.get(f"{self.base_url}/health")
+            ok = resp.status_code == 200
+            if not ok:
+                logger.warning("vLLM health check failed: status %d", resp.status_code)
+            return ok
+        except httpx.HTTPError as e:
+            logger.warning("vLLM health check error: %s", e)
+            return False
+
+    async def list_available_models(self) -> list[dict]:
+        primary_ok = await self.check_health()
+        lite_ok = await self.check_lite_health()
+        result = []
+        for info in settings.MODEL_INFO:
+            if info["id"] == "nyx-lite":
+                if self._lite_client:
+                    result.append({**info, "available": lite_ok})
+            else:
+                result.append({**info, "available": primary_ok})
+        return result

kairo/backend/services/project_service.py

@@ -0,0 +1,109 @@
+import logging
+
+from sqlalchemy import select, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from backend.models.conversation import Conversation
+from backend.models.project import Project
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectService:
+    def __init__(self, db: AsyncSession, user_id: str):
+        self.db = db
+        self.user_id = user_id
+
+    async def create(self, name: str) -> Project:
+        project = Project(name=name, user_id=self.user_id)
+        self.db.add(project)
+        await self.db.commit()
+        await self.db.refresh(project)
+        return project
+
+    async def get(self, project_id: str) -> Project | None:
+        stmt = (
+            select(Project)
+            .options(selectinload(Project.conversations))
+            .where(Project.id == project_id, Project.user_id == self.user_id)
+        )
+        result = await self.db.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def list_all(self) -> list[dict]:
+        stmt = (
+            select(
+                Project.id,
+                Project.name,
+                Project.instructions,
+                Project.created_at,
+                Project.updated_at,
+                func.count(Conversation.id).label("conversation_count"),
+            )
+            .outerjoin(Conversation, Conversation.project_id == Project.id)
+            .where(Project.user_id == self.user_id)
+            .group_by(Project.id)
+            .order_by(Project.updated_at.desc())
+        )
+        result = await self.db.execute(stmt)
+        rows = result.all()
+        return [
+            {
+                "id": r.id,
+                "name": r.name,
+                "instructions": r.instructions,
+                "created_at": r.created_at,
+                "updated_at": r.updated_at,
+                "conversation_count": r.conversation_count,
+            }
+            for r in rows
+        ]
+
+    async def update(self, project_id: str, **kwargs) -> Project | None:
+        project = await self.get(project_id)
+        if not project:
+            return None
+        for key, value in kwargs.items():
+            if hasattr(project, key):
+                setattr(project, key, value)
+        await self.db.commit()
+        await self.db.refresh(project)
+        return project
+
+    async def delete(self, project_id: str) -> bool:
+        project = await self.get(project_id)
+        if not project:
+            return False
+        await self.db.delete(project)
+        await self.db.commit()
+        return True
+
+    async def add_conversation(self, project_id: str, conversation_id: str) -> bool:
+        project = await self.get(project_id)
+        if not project:
+            return False
+        stmt = (
+            select(Conversation)
+            .where(Conversation.id == conversation_id, Conversation.user_id == self.user_id)
+        )
+        result = await self.db.execute(stmt)
+        conv = result.scalar_one_or_none()
+        if not conv:
+            return False
+        conv.project_id = project_id
+        await self.db.commit()
+        return True
+
+    async def remove_conversation(self, conversation_id: str) -> bool:
+        stmt = (
+            select(Conversation)
+            .where(Conversation.id == conversation_id, Conversation.user_id == self.user_id)
+        )
+        result = await self.db.execute(stmt)
+        conv = result.scalar_one_or_none()
+        if not conv:
+            return False
+        conv.project_id = None
+        await self.db.commit()
+        return True

kairo/backend/services/status_service.py

@@ -0,0 +1,167 @@
+import logging
+import time
+from collections import defaultdict
+from datetime import datetime, timedelta, UTC
+
+import httpx
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.config import settings
+from backend.models.incident import Incident
+from backend.models.uptime_record import UptimeRecord
+from backend.services.llm_service import LLMService
+
+logger = logging.getLogger(__name__)
+
+
+class StatusService:
+    """Public-facing service that aggregates health data for the status page."""
+
+    def __init__(self, db: AsyncSession, llm_service: LLMService):
+        self.db = db
+        self.llm = llm_service
+
+    async def get_status_page(self) -> dict:
+        """Aggregate all status data for the public status page."""
+        components = await self._get_component_statuses()
+        incidents = await self._get_recent_incidents(limit=10)
+        uptime = await self._get_uptime_history(days=90)
+        overall = self._determine_overall_status(components)
+        overall_uptime = self._calculate_overall_uptime(uptime)
+
+        return {
+            "status": overall,
+            "overall_uptime": overall_uptime,
+            "checked_at": datetime.now(UTC).isoformat(),
+            "components": components,
+            "recent_incidents": incidents,
+            "uptime_history": uptime,
+        }
+
+    async def _get_component_statuses(self) -> list[dict]:
+        """Check each component's current health status."""
+        components = []
+
+        # API/Chat -- if this code is executing, the API is up
+        components.append({"name": "API", "status": "operational", "latency_ms": None})
+
+        # Models (vLLM primary + lite)
+        primary_ok = getattr(self.llm, "primary_healthy", False)
+        lite_ok = getattr(self.llm, "lite_healthy", False)
+        if primary_ok:
+            model_status = "operational"
+        elif lite_ok:
+            model_status = "degraded"
+        else:
+            model_status = "down"
+        components.append({"name": "Models", "status": model_status, "latency_ms": None})
+
+        # Image Generation
+        if settings.FEATURE_IMAGE_GEN_ENABLED and settings.FLUX_BASE_URL:
+            try:
+                async with httpx.AsyncClient(timeout=5.0) as client:
+                    t0 = time.monotonic()
+                    resp = await client.get(f"{settings.FLUX_BASE_URL}/health")
+                    latency = int((time.monotonic() - t0) * 1000)
+                    if resp.status_code == 200:
+                        components.append({"name": "Image Generation", "status": "operational", "latency_ms": latency})
+                    else:
+                        components.append({"name": "Image Generation", "status": "degraded", "latency_ms": latency})
+            except Exception:
+                components.append({"name": "Image Generation", "status": "down", "latency_ms": None})
+        else:
+            components.append({"name": "Image Generation", "status": "down", "latency_ms": None})
+
+        # Database -- if we got this far, DB is operational
+        components.append({"name": "Database", "status": "operational", "latency_ms": None})
+
+        # Check for any active (unresolved) incidents that override component status
+        active_incidents = await self._get_active_incidents()
+        component_map = {
+            "api": "API",
+            "chat": "API",
+            "models": "Models",
+            "images": "Image Generation",
+            "database": "Database",
+        }
+        for incident in active_incidents:
+            comp_name = component_map.get(incident.component)
+            if not comp_name:
+                continue
+            for comp in components:
+                if comp["name"] == comp_name:
+                    # Escalate status based on incident severity
+                    if incident.severity == "critical":
+                        comp["status"] = "down"
+                    elif incident.severity == "warning" and comp["status"] == "operational":
+                        comp["status"] = "degraded"
+
+        return components
+
+    async def _get_active_incidents(self) -> list[Incident]:
+        """Get all unresolved incidents."""
+        stmt = (
+            select(Incident)
+            .where(Incident.status != "resolved")
+            .order_by(Incident.started_at.desc())
+        )
+        result = await self.db.execute(stmt)
+        return list(result.scalars().all())
+
+    async def _get_recent_incidents(self, limit: int = 10) -> list[dict]:
+        """Get recent incidents ordered by started_at descending."""
+        stmt = (
+            select(Incident)
+            .order_by(Incident.started_at.desc())
+            .limit(limit)
+        )
+        result = await self.db.execute(stmt)
+        return [
+            {
+                "id": i.id,
+                "title": i.title,
+                "description": i.description,
+                "severity": i.severity,
+                "component": i.component,
+                "status": i.status,
+                "started_at": i.started_at.isoformat(),
+                "resolved_at": i.resolved_at.isoformat() if i.resolved_at else None,
+            }
+            for i in result.scalars().all()
+        ]
+
+    async def _get_uptime_history(self, days: int = 90) -> list[dict]:
+        """Get daily uptime percentages for the last N days, averaged across components."""
+        start = datetime.now(UTC) - timedelta(days=days)
+        stmt = (
+            select(UptimeRecord)
+            .where(UptimeRecord.date >= start.date())
+            .order_by(UptimeRecord.date.desc())
+        )
+        result = await self.db.execute(stmt)
+
+        # Group by date, average across all components
+        date_uptimes: dict[str, list[float]] = defaultdict(list)
+        for r in result.scalars().all():
+            date_uptimes[str(r.date)].append(r.uptime_percent)
+
+        return [
+            {"date": d, "uptime_percent": round(sum(vals) / len(vals), 2)}
+            for d, vals in sorted(date_uptimes.items(), reverse=True)
+        ]
+
+    def _determine_overall_status(self, components: list[dict]) -> str:
+        """Determine overall system status from component statuses."""
+        statuses = [c["status"] for c in components]
+        if any(s == "down" for s in statuses):
+            return "outage"
+        if any(s == "degraded" for s in statuses):
+            return "degraded"
+        return "operational"
+
+    def _calculate_overall_uptime(self, history: list[dict]) -> float:
+        """Calculate overall uptime percentage from history entries."""
+        if not history:
+            return 100.0
+        return round(sum(h["uptime_percent"] for h in history) / len(history), 2)

kairo/backend/services/stripe_service.py

@@ -0,0 +1,78 @@
+import logging
+
+import stripe
+
+from backend.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class StripeService:
+    def __init__(self) -> None:
+        stripe.api_key = settings.STRIPE_SECRET_KEY
+
+    def create_checkout_session(self, user_id: str, email: str, stripe_customer_id: str | None) -> tuple[str, str]:
+        """Create a Stripe Checkout session. Returns (checkout_url, customer_id)."""
+        if stripe_customer_id:
+            customer_id = stripe_customer_id
+        else:
+            customer = stripe.Customer.create(email=email, metadata={"kairo_user_id": user_id})
+            customer_id = customer.id
+
+        session = stripe.checkout.Session.create(
+            customer=customer_id,
+            mode="subscription",
+            line_items=[{"price": settings.STRIPE_PRO_PRICE_ID, "quantity": 1}],
+            success_url=f"{settings.APP_BASE_URL}/account?checkout=success",
+            cancel_url=f"{settings.APP_BASE_URL}/pricing?checkout=cancelled",
+            metadata={"kairo_user_id": user_id},
+        )
+        if not session.url:
+            raise RuntimeError("Stripe did not return a checkout URL")
+        return session.url, customer_id
+
+    def create_billing_portal_session(self, stripe_customer_id: str) -> str:
+        """Create a Stripe Billing Portal session. Returns the portal URL."""
+        session = stripe.billing_portal.Session.create(
+            customer=stripe_customer_id,
+            return_url=f"{settings.APP_BASE_URL}/account",
+        )
+        return session.url
+
+    def handle_webhook_event(self, payload: bytes, sig: str) -> dict:
+        """Verify and parse a Stripe webhook event. Returns action dict."""
+        event = stripe.Webhook.construct_event(payload, sig, settings.STRIPE_WEBHOOK_SECRET)
+        event_type = event["type"]
+        data = event["data"]["object"]
+
+        if event_type == "checkout.session.completed":
+            customer_id = data["customer"]
+            subscription_id = data["subscription"]
+            user_id = data.get("metadata", {}).get("kairo_user_id")
+            logger.info("Checkout completed: customer=%s user=%s", customer_id, user_id)
+            return {
+                "action": "upgrade",
+                "customer_id": customer_id,
+                "subscription_id": subscription_id,
+                "user_id": user_id,
+            }
+
+        if event_type == "customer.subscription.updated":
+            customer_id = data["customer"]
+            status = data["status"]
+            logger.info("Subscription updated: customer=%s status=%s", customer_id, status)
+            if status == "active":
+                return {"action": "sync_active", "customer_id": customer_id, "subscription_id": data["id"]}
+            return {"action": "noop"}
+
+        if event_type == "customer.subscription.deleted":
+            customer_id = data["customer"]
+            logger.info("Subscription deleted: customer=%s", customer_id)
+            return {"action": "downgrade", "customer_id": customer_id}
+
+        if event_type == "invoice.payment_failed":
+            customer_id = data["customer"]
+            logger.warning("Payment failed: customer=%s", customer_id)
+            return {"action": "payment_failed", "customer_id": customer_id}
+
+        return {"action": "noop"}

kairo/backend/services/usage_service.py

@@ -0,0 +1,150 @@
+import logging
+from datetime import datetime, timezone, timedelta
+
+from sqlalchemy import select, func
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.config import settings
+from backend.models.usage import UsageRecord
+from backend.models.user import PlanType, User
+
+logger = logging.getLogger(__name__)
+
+PLAN_LIMITS: dict[str, dict[str, int]] = {
+    PlanType.FREE.value: {
+        "daily": settings.DEFAULT_DAILY_TOKEN_LIMIT,
+        "monthly": settings.DEFAULT_MONTHLY_TOKEN_LIMIT,
+    },
+    PlanType.PRO.value: {
+        "daily": settings.PRO_DAILY_TOKEN_LIMIT,
+        "monthly": settings.PRO_MONTHLY_TOKEN_LIMIT,
+    },
+    PlanType.MAX.value: {
+        "daily": settings.MAX_DAILY_TOKEN_LIMIT,
+        "monthly": settings.MAX_MONTHLY_TOKEN_LIMIT,
+    },
+}
+
+
+def _get_plan_limits(plan: str) -> tuple[int, int]:
+    limits = PLAN_LIMITS.get(plan, PLAN_LIMITS[PlanType.FREE.value])
+    return limits["daily"], limits["monthly"]
+
+
+class UsageService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def record_usage(
+        self,
+        user_id: str,
+        conversation_id: str | None,
+        model: str,
+        prompt_tokens: int,
+        completion_tokens: int,
+    ) -> UsageRecord:
+        record = UsageRecord(
+            user_id=user_id,
+            conversation_id=conversation_id,
+            model=model,
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+        )
+        self.db.add(record)
+        await self.db.commit()
+        await self.db.refresh(record)
+        logger.info(
+            "Usage recorded: user=%s prompt=%d completion=%d",
+            user_id, prompt_tokens, completion_tokens,
+        )
+        return record
+
+    async def get_daily_usage(self, user_id: str) -> int:
+        now = datetime.now(timezone.utc)
+        start_of_day = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        stmt = (
+            select(
+                func.coalesce(
+                    func.sum(UsageRecord.prompt_tokens + UsageRecord.completion_tokens), 0
+                )
+            )
+            .where(UsageRecord.user_id == user_id)
+            .where(UsageRecord.created_at >= start_of_day)
+        )
+        result = await self.db.execute(stmt)
+        return result.scalar() or 0
+
+    async def get_monthly_usage(self, user_id: str) -> int:
+        now = datetime.now(timezone.utc)
+        start_of_month = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+        stmt = (
+            select(
+                func.coalesce(
+                    func.sum(UsageRecord.prompt_tokens + UsageRecord.completion_tokens), 0
+                )
+            )
+            .where(UsageRecord.user_id == user_id)
+            .where(UsageRecord.created_at >= start_of_month)
+        )
+        result = await self.db.execute(stmt)
+        return result.scalar() or 0
+
+    async def check_limits(self, user_id: str) -> tuple[bool, str]:
+        """Returns (allowed, reason). allowed=True if under limits."""
+        user = await self.db.get(User, user_id)
+        if not user:
+            return False, "User not found"
+
+        daily_limit, monthly_limit = _get_plan_limits(user.plan)
+
+        daily = await self.get_daily_usage(user_id)
+        if daily >= daily_limit:
+            return False, "Daily token limit reached. Try again tomorrow."
+
+        monthly = await self.get_monthly_usage(user_id)
+        if monthly >= monthly_limit:
+            return False, "Monthly token limit reached."
+
+        return True, ""
+
+    async def get_usage_summary(self, user_id: str) -> dict:
+        user = await self.db.get(User, user_id)
+        daily_used = await self.get_daily_usage(user_id)
+        monthly_used = await self.get_monthly_usage(user_id)
+
+        daily_limit, monthly_limit = _get_plan_limits(user.plan if user else PlanType.FREE.value)
+
+        daily_pct = round((daily_used / daily_limit) * 100, 1) if daily_limit else 0
+        monthly_pct = round((monthly_used / monthly_limit) * 100, 1) if monthly_limit else 0
+
+        return {
+            "daily_percent": min(100, daily_pct),
+            "monthly_percent": min(100, monthly_pct),
+        }
+
+    async def get_usage_history(self, user_id: str, days: int = 30) -> list[dict]:
+        user = await self.db.get(User, user_id)
+        daily_limit, _ = _get_plan_limits(user.plan if user else PlanType.FREE.value)
+
+        start = datetime.now(timezone.utc) - timedelta(days=days)
+        stmt = (
+            select(
+                func.date(UsageRecord.created_at).label("date"),
+                func.sum(UsageRecord.prompt_tokens + UsageRecord.completion_tokens).label("total_tokens"),
+            )
+            .where(UsageRecord.user_id == user_id)
+            .where(UsageRecord.created_at >= start)
+            .group_by(func.date(UsageRecord.created_at))
+            .order_by(func.date(UsageRecord.created_at))
+        )
+        result = await self.db.execute(stmt)
+        rows = result.all()
+        return [
+            {
+                "date": str(r.date),
+                "usage_percent": round(
+                    min(100, ((r.total_tokens or 0) / daily_limit) * 100), 1
+                ) if daily_limit else 0,
+            }
+            for r in rows
+        ]