kairo-code 0.1.0__py3-none-any.whl

kairo/backend/core/rate_limit.py

@@ -0,0 +1,73 @@
+import time
+from collections import defaultdict
+
+from fastapi import HTTPException, Request
+
+# IPs of known reverse proxies (e.g., nginx on localhost, Docker bridge)
+_TRUSTED_PROXIES = {"127.0.0.1", "::1", "172.17.0.1", "172.18.0.1"}
+
+
+class SlidingWindowRateLimiter:
+    """In-memory sliding window rate limiter."""
+
+    def __init__(self, max_requests: int, window_seconds: int):
+        self.max_requests = max_requests
+        self.window_seconds = window_seconds
+        self._requests: dict[str, list[float]] = defaultdict(list)
+
+    def _clean(self, key: str, now: float) -> None:
+        cutoff = now - self.window_seconds
+        self._requests[key] = [t for t in self._requests[key] if t > cutoff]
+        if not self._requests[key]:
+            del self._requests[key]
+
+    def check(self, key: str) -> bool:
+        now = time.monotonic()
+        self._clean(key, now)
+        if len(self._requests.get(key, [])) >= self.max_requests:
+            return False
+        self._requests[key].append(now)
+        return True
+
+
+# 10 requests/minute per IP for auth endpoints
+_auth_limiter = SlidingWindowRateLimiter(max_requests=10, window_seconds=60)
+
+# 30 requests/minute per IP for chat endpoints
+_chat_limiter = SlidingWindowRateLimiter(max_requests=30, window_seconds=60)
+
+
+def _client_ip(request: Request) -> str:
+    """Get client IP, only trusting X-Forwarded-For from known proxies."""
+    real_ip = request.client.host if request.client else "unknown"
+    if real_ip in _TRUSTED_PROXIES:
+        forwarded = request.headers.get("x-forwarded-for")
+        if forwarded:
+            return forwarded.split(",")[0].strip()
+    return real_ip
+
+
+async def rate_limit_auth(request: Request) -> None:
+    key = f"auth:{_client_ip(request)}"
+    if not _auth_limiter.check(key):
+        raise HTTPException(status_code=429, detail="Too many requests. Try again later.")
+
+
+async def rate_limit_chat(request: Request) -> None:
+    key = f"chat:{_client_ip(request)}"
+    if not _chat_limiter.check(key):
+        raise HTTPException(status_code=429, detail="Too many requests. Try again later.")
+
+
+# 60 requests/minute per API key
+_api_limiter = SlidingWindowRateLimiter(max_requests=60, window_seconds=60)
+
+
+async def rate_limit_api(request: Request) -> None:
+    auth = request.headers.get("Authorization", "")
+    if auth.startswith("Bearer sk-kairo-"):
+        key = f"api:{auth[7:27]}"  # use key prefix
+    else:
+        key = f"api:{_client_ip(request)}"
+    if not _api_limiter.check(key):
+        raise HTTPException(status_code=429, detail="API rate limit exceeded.")

kairo/backend/core/security.py

@@ -0,0 +1,29 @@
+from datetime import datetime, timedelta, timezone
+
+import bcrypt
+from jose import JWTError, jwt
+
+from backend.config import settings
+
+
+def hash_password(password: str) -> str:
+    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    return bcrypt.checkpw(plain.encode("utf-8"), hashed.encode("utf-8"))
+
+
+def create_access_token(user_id: str) -> str:
+    expire = datetime.now(timezone.utc) + timedelta(hours=settings.JWT_EXPIRE_HOURS)
+    payload = {"sub": user_id, "exp": expire}
+    return jwt.encode(payload, settings.JWT_SECRET_KEY, algorithm="HS256")
+
+
+def decode_token(token: str) -> str | None:
+    """Returns user_id if valid, None otherwise."""
+    try:
+        payload = jwt.decode(token, settings.JWT_SECRET_KEY, algorithms=["HS256"])
+        return payload.get("sub")
+    except JWTError:
+        return None

kairo/backend/models/__init__.py

@@ -0,0 +1,19 @@
+from backend.models.conversation import Conversation, Message
+from backend.models.project import Project
+from backend.models.user import User, PlanType, RoleType
+from backend.models.usage import UsageRecord
+from backend.models.api_key import ApiKey
+from backend.models.agent import Agent
+from backend.models.api_usage import ApiUsageRecord
+from backend.models.image_generation import ImageGeneration
+from backend.models.audit_log import AuditLog
+from backend.models.feature_flag import FeatureFlag
+from backend.models.device_code import DeviceCode
+from backend.models.incident import Incident
+from backend.models.uptime_record import UptimeRecord
+
+__all__ = [
+    "Conversation", "Message", "Project", "User", "PlanType", "RoleType",
+    "UsageRecord", "ApiKey", "Agent", "ApiUsageRecord", "ImageGeneration",
+    "AuditLog", "FeatureFlag", "DeviceCode", "Incident", "UptimeRecord",
+]

kairo/backend/models/agent.py

@@ -0,0 +1,30 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, ForeignKey, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class Agent(Base):
+    __tablename__ = "agents"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id: Mapped[str] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), index=True)
+    api_key_id: Mapped[str | None] = mapped_column(
+        ForeignKey("api_keys.id", ondelete="SET NULL"), nullable=True
+    )
+    name: Mapped[str] = mapped_column(String)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+    system_prompt: Mapped[str | None] = mapped_column(Text, nullable=True)
+    model_preference: Mapped[str] = mapped_column(String, default="nyx")
+    tools_config: Mapped[str | None] = mapped_column(Text, nullable=True)
+    status: Mapped[str] = mapped_column(String, default="offline")
+    last_heartbeat_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC), onupdate=lambda: datetime.now(UTC)
+    )

kairo/backend/models/api_key.py

@@ -0,0 +1,25 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class ApiKey(Base):
+    __tablename__ = "api_keys"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id: Mapped[str] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), index=True)
+    name: Mapped[str] = mapped_column(String)
+    key_prefix: Mapped[str] = mapped_column(String, index=True)
+    key_hash: Mapped[str] = mapped_column(String)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    last_used_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+    expires_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    key_type: Mapped[str] = mapped_column(String, default="api")
+    rate_limit_rpm: Mapped[int] = mapped_column(Integer, default=60)

kairo/backend/models/api_usage.py

@@ -0,0 +1,29 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class ApiUsageRecord(Base):
+    __tablename__ = "api_usage_records"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    api_key_id: Mapped[str] = mapped_column(
+        ForeignKey("api_keys.id", ondelete="CASCADE"), index=True
+    )
+    user_id: Mapped[str] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), index=True
+    )
+    agent_id: Mapped[str | None] = mapped_column(
+        ForeignKey("agents.id", ondelete="SET NULL"), nullable=True
+    )
+    model: Mapped[str] = mapped_column(String)
+    prompt_tokens: Mapped[int] = mapped_column(Integer)
+    completion_tokens: Mapped[int] = mapped_column(Integer)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+    endpoint: Mapped[str] = mapped_column(String)

kairo/backend/models/audit_log.py

@@ -0,0 +1,26 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, ForeignKey, String, Text
+from sqlalchemy.dialects.postgresql import JSON
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class AuditLog(Base):
+    __tablename__ = "audit_logs"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    admin_user_id: Mapped[str] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"))
+    action: Mapped[str] = mapped_column(String)
+    target_type: Mapped[str] = mapped_column(String)
+    target_id: Mapped[str | None] = mapped_column(String, nullable=True)
+    details: Mapped[dict | None] = mapped_column(JSON, nullable=True)
+    result: Mapped[str] = mapped_column(String, default="success")
+    ip_address: Mapped[str | None] = mapped_column(String, nullable=True)
+    user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
+    session_id: Mapped[str | None] = mapped_column(String, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )

kairo/backend/models/conversation.py

@@ -0,0 +1,48 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, ForeignKey, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from backend.core.database import Base
+
+
+class Conversation(Base):
+    __tablename__ = "conversations"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    title: Mapped[str] = mapped_column(default="New Conversation")
+    model: Mapped[str] = mapped_column(default="nyx")
+    user_id: Mapped[str | None] = mapped_column(ForeignKey("users.id"), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+    summary: Mapped[str | None] = mapped_column(Text, nullable=True, default=None)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(UTC),
+        onupdate=lambda: datetime.now(UTC),
+    )
+    project_id: Mapped[str | None] = mapped_column(
+        ForeignKey("projects.id", ondelete="SET NULL"), nullable=True, default=None
+    )
+
+    messages: Mapped[list["Message"]] = relationship(
+        back_populates="conversation", cascade="all, delete-orphan", order_by="Message.created_at"
+    )
+    project: Mapped["Project | None"] = relationship(back_populates="conversations")  # noqa: F821
+
+
+class Message(Base):
+    __tablename__ = "messages"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    conversation_id: Mapped[str] = mapped_column(ForeignKey("conversations.id", ondelete="CASCADE"))
+    role: Mapped[str] = mapped_column()  # "user", "assistant", "system"
+    content: Mapped[str] = mapped_column(Text)
+    image_url: Mapped[str | None] = mapped_column(String, nullable=True, default=None)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+
+    conversation: Mapped["Conversation"] = relationship(back_populates="messages")

kairo/backend/models/device_code.py

@@ -0,0 +1,30 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class DeviceCode(Base):
+    __tablename__ = "device_codes"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    device_code: Mapped[str] = mapped_column(String, unique=True, index=True)
+    user_code: Mapped[str] = mapped_column(String, unique=True, index=True)
+    user_id: Mapped[str | None] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), nullable=True
+    )
+    status: Mapped[str] = mapped_column(String, default="pending")
+    cli_api_key_id: Mapped[str | None] = mapped_column(
+        ForeignKey("api_keys.id", ondelete="SET NULL"), nullable=True
+    )
+    expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+    approved_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    client_name: Mapped[str | None] = mapped_column(String, nullable=True)
+    cli_token: Mapped[str | None] = mapped_column(String, nullable=True)
+    interval: Mapped[int] = mapped_column(Integer, default=5)

kairo/backend/models/feature_flag.py

@@ -0,0 +1,21 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class FeatureFlag(Base):
+    __tablename__ = "feature_flags"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    key: Mapped[str] = mapped_column(String, unique=True)
+    enabled: Mapped[bool] = mapped_column(Boolean, default=False)
+    updated_by: Mapped[str | None] = mapped_column(
+        ForeignKey("users.id", ondelete="SET NULL"), nullable=True
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )

kairo/backend/models/image_generation.py

@@ -0,0 +1,24 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class ImageGeneration(Base):
+    __tablename__ = "image_generations"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id: Mapped[str] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"))
+    conversation_id: Mapped[str | None] = mapped_column(
+        ForeignKey("conversations.id", ondelete="SET NULL"), nullable=True
+    )
+    prompt: Mapped[str] = mapped_column(String)
+    image_url: Mapped[str] = mapped_column(String)
+    width: Mapped[int] = mapped_column(Integer, default=1024)
+    height: Mapped[int] = mapped_column(Integer, default=1024)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )

kairo/backend/models/incident.py

@@ -0,0 +1,28 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, Index, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class Incident(Base):
+    __tablename__ = "incidents"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    title: Mapped[str] = mapped_column(String)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+    severity: Mapped[str] = mapped_column(String, default="warning")  # info, warning, critical
+    component: Mapped[str] = mapped_column(String, index=True)  # api, chat, models, images, database
+    status: Mapped[str] = mapped_column(String, index=True, default="investigating")  # investigating, identified, monitoring, resolved
+    started_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), index=True, default=lambda: datetime.now(UTC)
+    )
+    resolved_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC), onupdate=lambda: datetime.now(UTC)
+    )

kairo/backend/models/project.py

@@ -0,0 +1,28 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, ForeignKey, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from backend.core.database import Base
+
+
+class Project(Base):
+    __tablename__ = "projects"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    name: Mapped[str] = mapped_column()
+    instructions: Mapped[str | None] = mapped_column(Text, nullable=True, default=None)
+    user_id: Mapped[str] = mapped_column(ForeignKey("users.id"), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(UTC),
+        onupdate=lambda: datetime.now(UTC),
+    )
+
+    conversations: Mapped[list["Conversation"]] = relationship(  # noqa: F821
+        back_populates="project", order_by="Conversation.updated_at.desc()"
+    )

kairo/backend/models/uptime_record.py

@@ -0,0 +1,24 @@
+import uuid
+from datetime import date, datetime, UTC
+
+from sqlalchemy import Date, DateTime, Float, Index, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class UptimeRecord(Base):
+    __tablename__ = "uptime_records"
+    __table_args__ = (
+        Index("ix_uptime_records_component_date", "component", "date", unique=True),
+    )
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    component: Mapped[str] = mapped_column(String, index=True)
+    date: Mapped[date] = mapped_column(Date, index=True)
+    uptime_percent: Mapped[float] = mapped_column(Float, default=100.0)
+    incidents_count: Mapped[int] = mapped_column(Integer, default=0)
+    avg_latency_ms: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )

kairo/backend/models/usage.py

@@ -0,0 +1,24 @@
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import DateTime, ForeignKey, Integer
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class UsageRecord(Base):
+    __tablename__ = "usage_records"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id: Mapped[str] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"))
+    conversation_id: Mapped[str | None] = mapped_column(
+        ForeignKey("conversations.id", ondelete="SET NULL"), nullable=True
+    )
+    model: Mapped[str] = mapped_column()
+    prompt_tokens: Mapped[int] = mapped_column(Integer)
+    completion_tokens: Mapped[int] = mapped_column(Integer)
+    source: Mapped[str] = mapped_column(default="chat")
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )

kairo/backend/models/user.py

@@ -0,0 +1,49 @@
+import enum
+import uuid
+from datetime import datetime, timezone
+
+from sqlalchemy import Boolean, DateTime, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from backend.core.database import Base
+
+
+class PlanType(str, enum.Enum):
+    FREE = "free"
+    PRO = "pro"
+    MAX = "max"
+
+
+class RoleType(str, enum.Enum):
+    USER = "user"
+    MODERATOR = "moderator"
+    ADMIN = "admin"
+    SUPERADMIN = "superadmin"
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[str] = mapped_column(primary_key=True, default=lambda: str(uuid.uuid4()))
+    email: Mapped[str] = mapped_column(unique=True)
+    hashed_password: Mapped[str] = mapped_column()
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
+    daily_token_limit: Mapped[int] = mapped_column(Integer, default=100_000)
+    monthly_token_limit: Mapped[int] = mapped_column(Integer, default=2_000_000)
+
+    # Plan & Stripe
+    plan: Mapped[str] = mapped_column(String, default=PlanType.FREE.value)
+    stripe_customer_id: Mapped[str | None] = mapped_column(String, nullable=True, unique=True, index=True)
+    stripe_subscription_id: Mapped[str | None] = mapped_column(String, nullable=True)
+
+    # Role & Status
+    role: Mapped[str] = mapped_column(String, default=RoleType.USER.value)
+    status: Mapped[str] = mapped_column(String, default="active")
+
+    # Email verification
+    email_verified: Mapped[bool] = mapped_column(Boolean, default=False)
+    email_verification_token: Mapped[str | None] = mapped_column(String, nullable=True)
+
+    # Password reset
+    password_reset_token: Mapped[str | None] = mapped_column(String, nullable=True)
+    password_reset_expires: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)

kairo/backend/schemas/admin/audit.py

@@ -0,0 +1,28 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class AuditLogEntry(BaseModel):
+    id: str
+    admin_user_id: str
+    action: str
+    target_type: str
+    target_id: str | None = None
+    details: dict | None = None
+    result: str
+    ip_address: str | None = None
+    user_agent: str | None = None
+    session_id: str | None = None
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class AuditLogFilter(BaseModel):
+    admin_id: str | None = None
+    action: str | None = None
+    target_type: str | None = None
+    result: str | None = None
+    date_from: datetime | None = None
+    date_to: datetime | None = None

kairo/backend/schemas/admin/content.py

@@ -0,0 +1,53 @@
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class AdminConversationListItem(BaseModel):
+    id: str
+    title: str
+    model: str
+    user_id: str | None = None
+    message_count: int = 0
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class AdminMessageItem(BaseModel):
+    id: str
+    role: str
+    content: str
+    image_url: str | None = None
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class AdminConversationDetail(BaseModel):
+    id: str
+    title: str
+    model: str
+    user_id: str | None = None
+    created_at: datetime
+    updated_at: datetime
+    messages: list[AdminMessageItem] = []
+
+    model_config = {"from_attributes": True}
+
+
+class AdminImageListItem(BaseModel):
+    id: str
+    user_id: str
+    prompt: str
+    image_url: str
+    width: int
+    height: int
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class ContentDeleteRequest(BaseModel):
+    reason: str = Field(..., min_length=1, max_length=1000)