Models

from memsy import (
    # Request
    EventPayload,
    # Core responses
    IngestResponse,
    SearchResponse,
    SearchResult,
    SourceEvent,
    StatusResponse,
    HealthResponse,
    ClearResponse,
    # Onboarding
    OrgResource,
    RoleResource,
    TeamResource,
    # Console memories
    MemoryScopeInfo,
    MemoryItemResource,
    MemoryListResponse,
    MemoryStatsResponse,
    # Control-plane (api/)
    MeResponse,
    UsageSummaryResponse,
    DimensionUsage,
    UsageTimeseriesResponse,
    TimeseriesPoint,
    BillingSummary,
    PaymentMethod,
    UpcomingInvoice,
    Invoice,
    ApiKeyInfo,
    ApiKeyListResponse,
    CreateKeyResponse,
    EventItemResponse,
    EventListResponse,
    ProInterestResponse,
    # Observability
    UsageInfo,
    RateLimitInfo,
)

@dataclass
class EventPayload:
    actor_id: str
    session_id: str
    kind: str           # "user_message" | "assistant_message" | "tool_result" | "app_event"
    content: str
    ts: str | None = None        # optional ISO-8601 timestamp
    metadata: str | None = None  # optional JSON-serialised string
    role_id: str | None = None   # role scope for the event
    team_id: str | None = None   # team scope for the event

@dataclass
class IngestResponse:
    event_ids: list[str]
    usage: UsageInfo | None = None
    rate_limit: RateLimitInfo | None = None

@dataclass
class SearchResponse:
    results: list[SearchResult]
    usage: UsageInfo | None = None
    rate_limit: RateLimitInfo | None = None

@dataclass
class SearchResult:
    id: str
    content: str
    score: float
    metadata: dict[str, Any] | None = None

@dataclass
class SourceEvent:
    event_id: str
    kind: str
    content: str
    ts: str | None = None

@dataclass
class StatusResponse:
    completed_ids: list[str]
    failed_ids: list[str]
    pending_ids: list[str]
    total: int
    statuses: dict[str, str] | None = None  # event_id → status map
    usage: UsageInfo | None = None
    rate_limit: RateLimitInfo | None = None

@dataclass
class HealthResponse:
    status: str
    version: str = ""
    billing_enabled: bool | None = None       # present on control-plane /health
    components: dict[str, str] | None = None  # component → status map
    usage: UsageInfo | None = None
    rate_limit: RateLimitInfo | None = None

@dataclass
class ClearResponse:
    deleted: int
    usage: UsageInfo | None = None
    rate_limit: RateLimitInfo | None = None

@dataclass
class OrgResource:
    org_id: str
    name: str
    focus: str
    promotion_prompt: str
    created_at: str
    updated_at: str
    prompt_meta: dict[str, Any] | None = None

@dataclass
class RoleResource:
    role_id: str
    org_id: str
    name: str
    focus: str
    promotion_prompt: str
    created_at: str
    updated_at: str
    prompt_meta: dict[str, Any] | None = None

@dataclass
class TeamResource:
    team_id: str
    org_id: str
    name: str
    focus: str
    promotion_prompt: str
    created_at: str
    updated_at: str
    prompt_meta: dict[str, Any] | None = None

@dataclass
class MemoryScopeInfo:
    level: str               # "org" | "role" | "team" | "actor"
    actor_id: str | None = None
    team_id: str | None = None
    role_id: str | None = None

@dataclass
class MemoryItemResource:
    memory_id: str
    org_id: str
    scope: MemoryScopeInfo
    type: str
    kind: str
    memory_kind: str
    status: str
    text: str
    confidence: float
    strength: float  # bounded 0.0–5.0 by platform policy
    recall_count: int
    decay_half_life_days: float
    pinned: bool
    tags: list[str]
    entity_refs: list[dict[str, str]]
    source_event_ids: list[str]
    source_urls: list[str]
    summary: str | None = None
    payload: dict[str, Any] | None = None
    last_recalled_at: str | None = None
    effective_from: str | None = None
    effective_to: str | None = None
    observed_at: str | None = None
    created_at: str | None = None
    updated_at: str | None = None

@dataclass
class MemoryListResponse:
    items: list[MemoryItemResource]
    total: int
    limit: int
    offset: int

@dataclass
class MemoryStatsResponse:
    total: int
    total_memories: int
    active_memories: int
    by_type: dict[str, int]
    by_kind: dict[str, int]
    by_status: dict[str, int]
    avg_confidence: float
    avg_strength: float
    top_entities: list[dict[str, Any]]
    confidence_buckets: list[dict[str, Any]] | None = None
    date_range: dict[str, str | None] | None = None

@dataclass
class MeResponse:
    customer_id: str
    email: str
    tier: str
    is_superadmin: bool
    org_id: str
    is_billing_admin: bool
    user_id: str | None = None
    org_role: str | None = None

@dataclass
class DimensionUsage:
    dimension: str
    used: int
    limit: int | None = None
    overage_rate: float | None = None

@dataclass
class UsageSummaryResponse:
    org_id: str
    tier: str
    period_start: str
    period_end: str
    dimensions: list[DimensionUsage]

@dataclass
class TimeseriesPoint:
    date: str
    dimension: str
    quantity: int

@dataclass
class UsageTimeseriesResponse:
    org_id: str
    granularity: str
    data: list[TimeseriesPoint]

@dataclass
class PaymentMethod:
    brand: str
    last4: str
    exp_month: int
    exp_year: int

@dataclass
class UpcomingInvoice:
    amount_due: int   # amount in smallest currency unit (e.g. cents)
    currency: str
    period_end: int   # Unix timestamp from Stripe

@dataclass
class BillingSummary:
    tier: str
    purchased_seats: int
    assigned_seats: int
    available_seats: int
    stripe_customer_id: str | None = None
    payment_method: PaymentMethod | None = None
    upcoming_invoice: UpcomingInvoice | None = None
    subscription_status: str | None = None
    billing_contact: str | None = None
    stripe_subscription_id: str | None = None

@dataclass
class Invoice:
    id: str
    amount_due: int
    amount_paid: int
    currency: str
    status: str
    created: str              # stringified Unix timestamp as returned by the API
    hosted_invoice_url: str | None = None

@dataclass
class ApiKeyInfo:
    key_id: str
    prefix: str
    name: str
    scopes: list[str]
    is_active: bool
    created_at: str
    last_used_at: str | None = None
    expires_at: str | None = None

@dataclass
class ApiKeyListResponse:
    keys: list[ApiKeyInfo]
    max_keys: int
    active_count: int

@dataclass
class CreateKeyResponse:
    key_id: str
    raw_key: str      # shown once — store securely
    prefix: str
    name: str
    scopes: list[str]

@dataclass
class EventItemResponse:
    event_id: str
    org_id: str
    actor_id: str
    kind: str
    content: str
    ts: str
    session_id: str | None = None
    metadata: dict[str, Any] | None = None
    ingested_at: str | None = None

@dataclass
class EventListResponse:
    items: list[EventItemResponse]
    total: int
    limit: int
    offset: int

@dataclass
class ProInterestResponse:
    message: str

@dataclass
class UsageInfo:
    api_calls: int | None = None
    api_calls_limit: int | None = None
    events_ingested: int | None = None
    events_ingested_limit: int | None = None
    memory_stored: int | None = None
    memory_stored_limit: int | None = None
    llm_tokens: int | None = None
    llm_tokens_limit: int | None = None
    search_queries: int | None = None
    search_queries_limit: int | None = None
    plan: str | None = None

@dataclass
class RateLimitInfo:
    limit: int | None = None
    remaining: int | None = None
    reset: int | None = None  # Unix timestamp