kairo-code 0.1.0__py3-none-any.whl

kairo/backend/schemas/admin/stats.py

@@ -0,0 +1,77 @@
+from pydantic import BaseModel
+
+
+class OverviewStats(BaseModel):
+    total_users: int
+    active_today: int
+    active_7d: int
+    active_30d: int
+    pro_subscribers: int
+    max_subscribers: int
+    mrr: int
+    conversations_today: int
+    images_today: int
+
+
+class UserGrowthEntry(BaseModel):
+    date: str
+    signups: int
+
+
+class UsageStatsEntry(BaseModel):
+    date: str
+    total_tokens: int
+
+
+class RevenueStats(BaseModel):
+    free_count: int
+    pro_count: int
+    max_count: int
+
+
+class TopUserEntry(BaseModel):
+    user_id: str
+    email: str
+    total_tokens: int
+
+
+# --- Analytics endpoint schemas ---
+
+
+class DailyCountEntry(BaseModel):
+    date: str
+    count: int
+
+
+class DailyCountResponse(BaseModel):
+    data: list[DailyCountEntry]
+
+
+class DailyTokensEntry(BaseModel):
+    date: str
+    tokens: int
+
+
+class DailyTokensResponse(BaseModel):
+    data: list[DailyTokensEntry]
+
+
+class PlanDistributionEntry(BaseModel):
+    plan: str
+    count: int
+
+
+class PlanDistributionResponse(BaseModel):
+    data: list[PlanDistributionEntry]
+
+
+class TopUserAnalyticsEntry(BaseModel):
+    email: str
+    plan: str
+    total_tokens: int
+    conversations: int
+    images: int
+
+
+class TopUserAnalyticsResponse(BaseModel):
+    data: list[TopUserAnalyticsEntry]

kairo/backend/schemas/admin/system.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class ServiceHealth(BaseModel):
+    name: str
+    status: str  # "healthy" | "degraded" | "down"
+    latency_ms: int | None = None
+    message: str | None = None
+
+
+class HealthStatus(BaseModel):
+    overall: str  # "healthy" | "degraded" | "down"
+    services: list[ServiceHealth]
+    checked_at: str
+
+
+class FeatureFlagItem(BaseModel):
+    key: str
+    enabled: bool
+    updated_by: str | None = None
+    updated_at: str | None = None
+
+    model_config = {"from_attributes": True}
+
+
+class FeatureFlagResponse(BaseModel):
+    flags: list[FeatureFlagItem]
+
+
+class FeatureFlagUpdate(BaseModel):
+    key: str
+    enabled: bool
+    reason: str = ""
+
+
+class ConfigEntry(BaseModel):
+    key: str
+    value: str
+
+
+class ConfigResponse(BaseModel):
+    config: list[ConfigEntry]

kairo/backend/schemas/admin/users.py

@@ -0,0 +1,48 @@
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class AdminUserListItem(BaseModel):
+    id: str
+    email: str
+    role: str
+    status: str
+    plan: str
+    email_verified: bool
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class AdminUserDetailResponse(BaseModel):
+    """Allowlisted fields only — never expose hashed_password, tokens, etc."""
+
+    id: str
+    email: str
+    role: str
+    status: str
+    plan: str
+    created_at: datetime
+    email_verified: bool
+    stripe_customer_id: str | None = None
+    stripe_subscription_id: str | None = None
+    daily_token_limit: int
+    monthly_token_limit: int
+
+    model_config = {"from_attributes": True}
+
+
+class PlanChangeRequest(BaseModel):
+    plan: str = Field(..., description="New plan: free, pro, or max")
+    reason: str = Field(..., min_length=1, max_length=1000)
+
+
+class StatusChangeRequest(BaseModel):
+    status: str = Field(..., description="New status: active, suspended, or banned")
+    reason: str = Field(..., min_length=1, max_length=1000)
+
+
+class RoleChangeRequest(BaseModel):
+    role: str = Field(..., description="New role: user, moderator, admin, or superadmin")
+    reason: str = Field(..., min_length=1, max_length=1000)

kairo/backend/schemas/agent.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class RegisterAgentRequest(BaseModel):
+    name: str = Field(..., min_length=1, max_length=100)
+    description: str | None = Field(None, max_length=500)
+    system_prompt: str | None = Field(None, max_length=10000)
+    model_preference: str = "nyx"
+    tools: list[str] | None = None
+
+
+class UpdateAgentRequest(BaseModel):
+    name: str | None = Field(None, min_length=1, max_length=100)
+    description: str | None = None
+    system_prompt: str | None = Field(None, max_length=10000)
+    model_preference: str | None = None
+    tools: list[str] | None = None
+
+
+class AgentResponse(BaseModel):
+    id: str
+    name: str
+    description: str | None = None
+    model_preference: str
+    status: str
+    last_heartbeat_at: datetime | None = None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class AgentHeartbeatRequest(BaseModel):
+    agent_id: str
+    status: str = Field("online", pattern="^(online|busy|idle)$")
+
+
+class AgentHeartbeatResponse(BaseModel):
+    acknowledged: bool
+    server_time: datetime

kairo/backend/schemas/api_key.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class CreateApiKeyRequest(BaseModel):
+    name: str = Field(..., min_length=1, max_length=100)
+    expires_in_days: int | None = Field(None, ge=1, le=365)
+
+
+class ApiKeyResponse(BaseModel):
+    id: str
+    name: str
+    key_prefix: str
+    is_active: bool
+    last_used_at: datetime | None = None
+    created_at: datetime
+    expires_at: datetime | None = None
+
+    model_config = {"from_attributes": True}
+
+
+class ApiKeyCreatedResponse(ApiKeyResponse):
+    """Returned only once on creation — includes the full key."""
+    full_key: str
+
+
+class RevokeApiKeyResponse(BaseModel):
+    id: str
+    revoked: bool

kairo/backend/schemas/auth.py

@@ -0,0 +1,57 @@
+from datetime import datetime
+
+from pydantic import BaseModel, EmailStr, Field
+
+
+class RegisterRequest(BaseModel):
+    email: EmailStr = Field(..., max_length=254)
+    password: str = Field(..., min_length=8, max_length=128)
+
+
+class LoginRequest(BaseModel):
+    email: EmailStr = Field(..., max_length=254)
+    password: str = Field(..., max_length=128)
+
+
+class VerifyEmailRequest(BaseModel):
+    token: str = Field(..., max_length=128)
+
+
+class ForgotPasswordRequest(BaseModel):
+    email: EmailStr = Field(..., max_length=254)
+
+
+class ResetPasswordRequest(BaseModel):
+    token: str = Field(..., max_length=128)
+    password: str = Field(..., min_length=8, max_length=128)
+
+
+class UserResponse(BaseModel):
+    id: str
+    email: str
+    created_at: datetime
+    plan: str = "free"
+    email_verified: bool = False
+    role: str = "user"
+
+    model_config = {"from_attributes": True}
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    user: UserResponse
+
+
+class CheckoutResponse(BaseModel):
+    checkout_url: str
+
+
+class BillingPortalResponse(BaseModel):
+    portal_url: str
+
+
+class BillingStatusResponse(BaseModel):
+    plan: str
+    stripe_customer_id: str | None = None
+    stripe_subscription_id: str | None = None

kairo/backend/schemas/chat.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel, Field, field_validator
+
+from backend.config import settings
+
+
+class ChatRequest(BaseModel):
+    conversation_id: str | None = None
+    message: str = Field(..., min_length=1, max_length=32000)
+    model: str = "nyx"
+    temperature: float = Field(default=0.7, ge=0.0, le=2.0)
+    max_tokens: int = Field(default=2048, ge=1, le=16384)
+    project_id: str | None = None
+
+    @field_validator("model")
+    @classmethod
+    def model_must_be_allowed(cls, v: str) -> str:
+        allowed = set(settings.MODEL_MAP.keys())
+        if v not in allowed:
+            raise ValueError(f"model must be one of: {', '.join(sorted(allowed))}")
+        return v
+
+
+class StreamChunk(BaseModel):
+    type: str  # "meta", "content", "error"
+    conversation_id: str | None = None
+    content: str | None = None

kairo/backend/schemas/conversation.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class MessageSchema(BaseModel):
+    id: str
+    role: str
+    content: str
+    created_at: datetime
+    image_url: str | None = None
+
+    model_config = {"from_attributes": True}
+
+
+class ConversationSummary(BaseModel):
+    id: str
+    title: str
+    model: str
+    updated_at: datetime
+    message_count: int
+    project_id: str | None = None
+
+    model_config = {"from_attributes": True}
+
+
+class ConversationDetail(BaseModel):
+    id: str
+    title: str
+    model: str
+    created_at: datetime
+    updated_at: datetime
+    project_id: str | None = None
+    messages: list[MessageSchema]
+
+    model_config = {"from_attributes": True}
+
+
+class ConversationRename(BaseModel):
+    title: str = Field(..., min_length=1, max_length=200)

kairo/backend/schemas/device_auth.py

@@ -0,0 +1,40 @@
+from pydantic import BaseModel, Field
+
+
+class DeviceCodeRequest(BaseModel):
+    client_name: str = Field("kairo-code", max_length=100)
+
+
+class DeviceCodeResponse(BaseModel):
+    device_code: str
+    user_code: str
+    verification_uri: str
+    verification_uri_complete: str
+    expires_in: int
+    interval: int
+
+
+class DeviceTokenRequest(BaseModel):
+    device_code: str
+    grant_type: str = "urn:ietf:params:oauth:grant-type:device_code"
+
+
+class DeviceTokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    plan: str
+    email: str
+
+
+class DeviceTokenErrorResponse(BaseModel):
+    error: str  # authorization_pending, slow_down, expired_token, access_denied
+    error_description: str
+
+
+class DeviceApproveRequest(BaseModel):
+    user_code: str
+
+
+class DeviceApproveResponse(BaseModel):
+    approved: bool
+    message: str

kairo/backend/schemas/image.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, Field
+
+
+class ImageGenerateRequest(BaseModel):
+    prompt: str = Field(..., min_length=1, max_length=2000)
+    conversation_id: str | None = None
+    width: int = Field(default=1024, ge=256, le=2048)
+    height: int = Field(default=1024, ge=256, le=2048)
+
+
+class ImageGenerateResponse(BaseModel):
+    image_url: str
+    message_id: str
+    conversation_id: str
+    prompt: str

kairo/backend/schemas/openai_compat.py

@@ -0,0 +1,76 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str | None = None
+    name: str | None = None
+    tool_calls: list[dict[str, Any]] | None = None
+    tool_call_id: str | None = None
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: list[ChatMessage]
+    temperature: float = Field(0.7, ge=0.0, le=2.0)
+    max_tokens: int | None = Field(None, ge=1)
+    stream: bool = False
+    top_p: float | None = Field(None, ge=0.0, le=1.0)
+    stop: str | list[str] | None = None
+    # Tool calling
+    tools: list[dict[str, Any]] | None = None
+    tool_choice: str | dict[str, Any] | None = None
+    parallel_tool_calls: bool | None = None
+    # Additional OpenAI-compatible fields
+    response_format: dict[str, Any] | None = None
+    frequency_penalty: float | None = Field(None, ge=-2.0, le=2.0)
+    presence_penalty: float | None = Field(None, ge=-2.0, le=2.0)
+    seed: int | None = None
+    n: int | None = Field(None, ge=1, le=8)
+    logprobs: bool | None = None
+    top_logprobs: int | None = Field(None, ge=0, le=20)
+    user: str | None = None
+
+
+class ChoiceDelta(BaseModel):
+    role: str | None = None
+    content: str | None = None
+    tool_calls: list[dict[str, Any]] | None = None
+
+
+class ChatCompletionChoice(BaseModel):
+    index: int
+    message: ChatMessage
+    finish_reason: str | None = None
+
+
+class StreamChoice(BaseModel):
+    index: int
+    delta: ChoiceDelta
+    finish_reason: str | None = None
+
+
+class UsageInfo(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: list[ChatCompletionChoice]
+    usage: UsageInfo | None = None
+
+
+class ChatCompletionChunk(BaseModel):
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: list[StreamChoice]
+    usage: UsageInfo | None = None

kairo/backend/schemas/project.py

@@ -0,0 +1,21 @@
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class ProjectCreate(BaseModel):
+    name: str = Field(..., min_length=1, max_length=200)
+
+
+class ProjectUpdate(BaseModel):
+    name: str | None = Field(default=None, min_length=1, max_length=200)
+    instructions: str | None = None
+
+
+class ProjectResponse(BaseModel):
+    id: str
+    name: str
+    instructions: str | None
+    conversation_count: int
+    created_at: datetime
+    updated_at: datetime

kairo/backend/schemas/status.py

@@ -0,0 +1,81 @@
+from pydantic import BaseModel, field_validator
+
+
+class ComponentStatus(BaseModel):
+    name: str
+    status: str  # operational, degraded, down
+    latency_ms: int | None = None
+    uptime_24h: float | None = None
+
+
+class IncidentSummary(BaseModel):
+    id: str
+    title: str
+    description: str | None = None
+    severity: str
+    component: str
+    status: str
+    started_at: str
+    resolved_at: str | None = None
+
+
+class UptimeEntry(BaseModel):
+    date: str
+    uptime_percent: float
+
+
+class StatusPageResponse(BaseModel):
+    status: str  # operational, degraded, outage
+    overall_uptime: float
+    checked_at: str
+    components: list[ComponentStatus]
+    recent_incidents: list[IncidentSummary]
+    uptime_history: list[UptimeEntry]
+
+
+VALID_SEVERITIES = {"info", "warning", "critical"}
+VALID_COMPONENTS = {"api", "chat", "models", "images", "database"}
+VALID_STATUSES = {"investigating", "identified", "monitoring", "resolved"}
+
+
+class CreateIncidentRequest(BaseModel):
+    title: str
+    description: str | None = None
+    severity: str = "warning"
+    component: str
+
+    @field_validator("severity")
+    @classmethod
+    def validate_severity(cls, v: str) -> str:
+        if v not in VALID_SEVERITIES:
+            raise ValueError(f"severity must be one of {VALID_SEVERITIES}")
+        return v
+
+    @field_validator("component")
+    @classmethod
+    def validate_component(cls, v: str) -> str:
+        if v not in VALID_COMPONENTS:
+            raise ValueError(f"component must be one of {VALID_COMPONENTS}")
+        return v
+
+
+class UpdateIncidentRequest(BaseModel):
+    title: str | None = None
+    description: str | None = None
+    severity: str | None = None
+    status: str | None = None
+    resolved_at: str | None = None
+
+    @field_validator("severity")
+    @classmethod
+    def validate_severity(cls, v: str | None) -> str | None:
+        if v is not None and v not in VALID_SEVERITIES:
+            raise ValueError(f"severity must be one of {VALID_SEVERITIES}")
+        return v
+
+    @field_validator("status")
+    @classmethod
+    def validate_status(cls, v: str | None) -> str | None:
+        if v is not None and v not in VALID_STATUSES:
+            raise ValueError(f"status must be one of {VALID_STATUSES}")
+        return v

kairo/backend/schemas/usage.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+
+class UsageSummaryResponse(BaseModel):
+    daily_percent: float
+    monthly_percent: float
+
+
+class UsageHistoryEntry(BaseModel):
+    date: str
+    usage_percent: float
+
+
+class UsageHistoryResponse(BaseModel):
+    entries: list[UsageHistoryEntry]