aethergraph 0.1.0a1__py3-none-any.whl → 0.1.0a3__py3-none-any.whl

aethergraph/api/v1/session.py

@@ -0,0 +1,323 @@
+from datetime import datetime, timezone
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+
+from aethergraph.api.v1.deps import RequestIdentity, get_identity
+from aethergraph.api.v1.pagination import decode_cursor, encode_cursor
+from aethergraph.api.v1.runs import _extract_app_id_from_tags
+from aethergraph.api.v1.schemas import (
+    RunSummary,
+    Session,
+    SessionChatEvent,
+    SessionCreateRequest,
+    SessionListResponse,
+    SessionRunsResponse,
+    SessionUpdateRequest,
+)
+from aethergraph.core.runtime.run_types import RunImportance, RunVisibility, SessionKind
+from aethergraph.core.runtime.runtime_registry import current_registry
+from aethergraph.core.runtime.runtime_services import current_services
+
+router = APIRouter(tags=["sessions"])
+
+
+@router.post("/sessions", response_model=Session)
+async def create_session(
+    body: SessionCreateRequest,
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> Session:
+    """
+    Create a new session.
+    """
+    container = current_services()
+    ss = getattr(container, "session_store", None)
+    if ss is None:
+        raise HTTPException(status_code=500, detail="SessionStore not available")
+
+    sess = await ss.create(
+        kind=body.kind,
+        title=body.title,
+        external_ref=body.external_ref,
+        user_id=identity.user_id,
+        org_id=identity.org_id,
+        source="webui",
+    )
+
+    return sess
+
+
+@router.get("/sessions", response_model=SessionListResponse)
+async def list_sessions(
+    kind: SessionKind | None = Query(None, description="Filter sessions by kind"),  # noqa: B008
+    limit: int = Query(50, ge=1, le=1000),  # noqa: B008
+    cursor: str | None = Query(None),  # noqa: B008
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> SessionListResponse:
+    """
+    List sessions for the current user/org, optionally filtered by kind.
+    """
+    container = current_services()
+    ss = getattr(container, "session_store", None)
+    if ss is None:
+        raise HTTPException(status_code=500, detail="SessionStore not available")
+
+    offset = decode_cursor(cursor)
+
+    # Enforce identity for cloud/demo
+    if identity.mode in ("cloud", "demo") and identity.user_id is None:
+        raise HTTPException(status_code=403, detail="User identity required")
+
+    sessions = await ss.list_for_user(
+        user_id=identity.user_id if identity.mode in ("cloud", "demo") else identity.user_id,
+        org_id=identity.org_id if identity.mode in ("cloud", "demo") else identity.org_id,
+        kind=kind,
+        limit=limit,
+        offset=offset,
+    )
+    # print(f"Listed {len(sessions)} sessions for user_id={identity.user_id} org_id={identity.org_id} offset={offset} limit={limit}")
+    # print(f"Sessions: {[s for s in sessions]}")
+    next_cursor = encode_cursor(offset + limit) if len(sessions) == limit else None
+    return SessionListResponse(items=sessions, next_cursor=next_cursor)
+
+
+@router.get("/sessions/{session_id}", response_model=Session)
+async def get_session(
+    session_id: str,
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> Session:
+    container = current_services()
+    ss = getattr(container, "session_store", None)
+    if ss is None:
+        raise HTTPException(status_code=500, detail="SessionStore not available")
+
+    sess = await ss.get(session_id)
+    if sess is None:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    # Optional: enforce that the session belongs to the user/org
+    if identity.mode != "local":
+        if identity.user_id and sess.user_id is not None and sess.user_id != identity.user_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        if identity.org_id and sess.org_id is not None and sess.org_id != identity.org_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+    return sess
+
+
+@router.get("/sessions/{session_id}/runs", response_model=SessionRunsResponse)
+async def get_session_runs(
+    session_id: str,
+    include_inline: bool = Query(False),  # noqa: B008
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> SessionRunsResponse:
+    container = current_services()
+    ss = getattr(container, "session_store", None)
+    rm = getattr(container, "run_manager", None)
+    if ss is None:
+        raise HTTPException(status_code=500, detail="SessionStore not available")
+    if rm is None:
+        raise HTTPException(status_code=500, detail="RunManager not available")
+
+    # Make sure the session exists and belongs to this user/org
+    sess = await ss.get(session_id)
+    if sess is None:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    if identity.mode != "local":
+        if identity.user_id and sess.user_id is not None and sess.user_id != identity.user_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+        if identity.org_id and sess.org_id is not None and sess.org_id != identity.org_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+    # For now, just scan recent runs and filter by session_id
+    # Later, we need a dedicated index/query in RunStore
+    records = await rm.list_records(
+        graph_id=None,
+        status=None,
+        session_id=session_id,
+        flow_id=None,
+        limit=1000,
+        offset=0,
+    )
+
+    # 🔹 Visibility & importance policy for session views:
+    # - Always require importance == normal (ephemeral hidden for now).
+    # - If include_inline is False:
+    #       include only visibility == normal
+    #   Else:
+    #       include visibility in {normal, inline}
+    visible_states = {RunVisibility.normal}
+    if include_inline:
+        visible_states.add(RunVisibility.inline)
+
+    records = [
+        rec
+        for rec in records
+        if rec.visibility in visible_states and rec.importance == RunImportance.normal
+    ]
+
+    reg = getattr(container, "registry", None) or current_registry()
+    summaries: list[RunSummary] = []
+
+    for rec in records:
+        # defaults to avoid UnboundLocalError if reg is None
+        flow_id: str | None = None
+        entrypoint = False
+
+        if reg is not None:
+            if rec.kind == "taskgraph":
+                meta = reg.get_meta(nspace="graph", name=rec.graph_id, version=None) or {}
+            elif rec.kind == "graphfn":
+                meta = reg.get_meta(nspace="graphfn", name=rec.graph_id, version=None) or {}
+            else:
+                meta = {}
+
+            flow_id = meta.get("flow_id")
+            entrypoint = bool(meta.get("entrypoint", False))
+
+        # derive app info
+        app_id = rec.meta.get("app_id") or _extract_app_id_from_tags(rec.tags)
+        app_name = rec.meta.get("app_name")
+
+        summaries.append(
+            RunSummary(
+                run_id=rec.run_id,
+                graph_id=rec.graph_id,
+                status=rec.status,
+                started_at=rec.started_at,
+                finished_at=rec.finished_at,
+                tags=rec.tags,
+                user_id=rec.user_id,
+                org_id=rec.org_id,
+                graph_kind=rec.kind,
+                flow_id=flow_id,
+                entrypoint=entrypoint,
+                meta=rec.meta or {},
+                app_id=app_id,
+                app_name=app_name,
+                session_id=rec.session_id,
+                origin=rec.origin,
+                visibility=rec.visibility,
+                importance=rec.importance,
+                agent_id=rec.agent_id,
+            )
+        )
+
+    return SessionRunsResponse(items=summaries)
+
+
+@router.get("/sessions/{session_id}/chat/events", response_model=list[SessionChatEvent])
+async def get_session_chat_events(
+    session_id: str,
+    request: Request,
+    since_ts: float | None = Query(None),  # noqa: B008
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> list[SessionChatEvent]:
+    container = current_services()
+    event_log = container.eventlog
+
+    if event_log is None:
+        raise HTTPException(status_code=503, detail="EventLog not available")
+
+    since_dt: datetime | None = None
+    if since_ts is not None:
+        since_dt = datetime.fromtimestamp(since_ts, tz=timezone.utc)
+
+    events = await event_log.query(
+        scope_id=session_id,
+        since=since_dt,
+        kinds=["session_chat"],
+        limit=1000,
+    )
+
+    if since_ts is not None:
+        # make cursor exclusive -- only return events after since_ts to avoid duplicates
+        events = [ev for ev in events if (ev.get("ts") or 0) > since_ts]
+
+    out: list[SessionChatEvent] = []
+    for ev in events:
+        payload = ev.get("payload", {}) or {}
+        out.append(
+            SessionChatEvent(
+                id=ev.get("id"),
+                session_id=session_id,
+                ts=ev.get("ts"),
+                type=payload.get("type") or "agent.message",
+                text=payload.get("text"),
+                buttons=payload.get("buttons", []),
+                file=payload.get("file"),  # may be None
+                files=payload.get("files") or None,  # forward list
+                meta=payload.get("meta", {}) or {},
+                agent_id=payload.get("agent_id"),
+                upsert_key=payload.get("upsert_key"),  # forward idempotent key
+            )
+        )
+    out.sort(key=lambda e: e.ts)
+
+    return out
+
+
+@router.patch("/sessions/{session_id}", response_model=Session)
+async def update_session(
+    session_id: str,
+    body: SessionUpdateRequest,
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> Session:
+    container = current_services()
+    ss = getattr(container, "session_store", None)
+    if ss is None:
+        raise HTTPException(status_code=500, detail="SessionStore not available")
+
+    existing = await ss.get(session_id)
+    if existing is None:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    # Enforce ownership for non-local modes
+    if identity.mode != "local":
+        if (
+            identity.user_id
+            and existing.user_id is not None
+            and existing.user_id != identity.user_id
+        ):
+            raise HTTPException(status_code=403, detail="Access denied")
+        if identity.org_id and existing.org_id is not None and existing.org_id != identity.org_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+    updated = await ss.update(
+        session_id,
+        title=body.title,
+        external_ref=body.external_ref,
+    )
+    if updated is None:
+        # Defensive; shouldn't happen given we already fetched it
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    return updated
+
+
+@router.delete("/sessions/{session_id}", status_code=204)
+async def delete_session(
+    session_id: str,
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> None:
+    container = current_services()
+    ss = getattr(container, "session_store", None)
+    if ss is None:
+        raise HTTPException(status_code=500, detail="SessionStore not available")
+
+    existing = await ss.get(session_id)
+    if existing is None:
+        # 204 for idempotent delete
+        return
+
+    if identity.mode != "local":
+        if (
+            identity.user_id
+            and existing.user_id is not None
+            and existing.user_id != identity.user_id
+        ):
+            raise HTTPException(status_code=403, detail="Access denied")
+        if identity.org_id and existing.org_id is not None and existing.org_id != identity.org_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+    await ss.delete(session_id)

aethergraph/api/v1/stats.py

@@ -0,0 +1,201 @@
+from collections.abc import Iterable
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from aethergraph.core.runtime.runtime_services import current_services
+
+from .deps import RequestIdentity, get_identity
+from .schemas import (
+    ArtifactStats,
+    GraphStats,
+    GraphStatsEntry,
+    LLMStats,
+    MemoryStats,
+    StatsOverview,
+)
+
+router = APIRouter(tags=["stats"])
+
+
+# This is demo-only; real multi-tenant setups should rely on user_id/org_id instead.
+def _has_client_tag(tags: Iterable[str] | None, client_id: str | None) -> bool:
+    if not client_id:
+        return True
+    if not tags:
+        return False
+    needle = f"client:{client_id}"
+    return any(t == needle for t in tags)
+
+
+async def _get_run_ids_for_client(
+    client_id: str | None,
+    limit: int = 500,
+) -> set[str]:
+    """
+    TEMP: demo-only helper.
+    Look up recent runs and filter by client:<id> tag.
+    """
+    if not client_id:
+        return set()
+
+    container = current_services()
+    rm = getattr(container, "run_manager", None)
+    if rm is None:
+        return set()
+
+    records = await rm.list_records(
+        graph_id=None,
+        status=None,
+        flow_id=None,
+        limit=limit,
+    )
+
+    return {r.run_id for r in records if _has_client_tag(r.tags, client_id)}
+
+
+@router.get("/stats/overview", response_model=StatsOverview)
+async def get_stats_overview(
+    window: Annotated[str, Query(description="Time window for stats, e.g., '24h', '7d'")] = "24h",
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> StatsOverview:
+    """
+    Get an overview of usage statistics.
+
+    - **window**: Time window for stats (e.g., "24h", "7d").
+    """
+    container = current_services()
+    meter = getattr(container, "metering", None)
+    if meter is None:
+        raise HTTPException(status_code=501, detail="Metering service not available")
+
+    raw: dict[str, int] = await meter.get_overview(
+        user_id=identity.user_id if identity and identity.user_id else None,
+        org_id=identity.org_id if identity and identity.org_id else None,
+        window=window,
+    )
+    return StatsOverview(**raw)
+
+
+@router.get("/stats/graphs", response_model=GraphStats)
+async def get_graphs_stats(
+    window: Annotated[str, Query(description="Time window for stats, e.g., '24h', '7d'")] = "24h",
+    graph_id: Annotated[str | None, Query(description="Optional graph_id filter")] = None,
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> GraphStats:
+    """
+    Get usage statistics for graphs.
+
+    - **window**: Time window for stats (e.g., "24h", "7d").
+    - **graph_id**: Optional filter; if provided, only stats for that graph are returned.
+    """
+    container = current_services()
+    meter = getattr(container, "metering", None)
+    if meter is None:
+        raise HTTPException(status_code=501, detail="Metering service not available")
+
+    raw_all: dict[str, dict[str, Any]] = await meter.get_graph_stats(
+        user_id=identity.user_id if identity and identity.user_id else None,
+        org_id=identity.org_id if identity and identity.org_id else None,
+        window=window,
+    )
+    # raw_all: { "<graph_id>": {"runs":..., "succeeded":..., "failed":..., "total_duration_s":...}, ... }
+
+    if graph_id is not None:
+        # Return only the requested graph, but still in map form
+        entry = raw_all.get(graph_id, {})
+        filtered: dict[str, dict[str, Any]] = {
+            graph_id: {
+                "runs": int(entry.get("runs", 0)),
+                "succeeded": int(entry.get("succeeded", 0)),
+                "failed": int(entry.get("failed", 0)),
+                "total_duration_s": float(entry.get("total_duration_s", 0.0)),
+            }
+        }
+        return GraphStats(root={gid: GraphStatsEntry(**vals) for gid, vals in filtered.items()})
+
+    # Normalize all entries to GraphStatsEntry
+    normalized: dict[str, GraphStatsEntry] = {}
+    for gid, vals in raw_all.items():
+        normalized[gid] = GraphStatsEntry(
+            runs=int(vals.get("runs", 0)),
+            succeeded=int(vals.get("succeeded", 0)),
+            failed=int(vals.get("failed", 0)),
+            total_duration_s=float(vals.get("total_duration_s", 0.0)),
+        )
+
+    return GraphStats(root=normalized)
+
+
+@router.get("/stats/memory", response_model=MemoryStats)
+async def get_memory_stats(
+    scope_id: Annotated[str | None, Query(description="Logical memory scope (optional)")] = None,
+    window: Annotated[str, Query(description="Time window, e.g., '24h', '7d'")] = "24h",
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> MemoryStats:
+    """
+    Get memory usage statistics.
+
+    - **scope_id**: Logical memory scope (optional).
+    - **window**: Time window for stats (e.g., "24h", "7d").
+    """
+    container = current_services()
+    meter = getattr(container, "metering", None)
+
+    if meter is None:
+        raise HTTPException(status_code=501, detail="Metering service not available")
+
+    raw: dict[str, dict[str, int]] = await meter.get_memory_stats(
+        scope_id=scope_id,
+        user_id=identity.user_id if identity and identity.user_id else None,
+        org_id=identity.org_id if identity and identity.org_id else None,
+        window=window,
+    )
+    # raw: { "memory.user_msg": {"count": N}, ... }
+    return MemoryStats(root=raw)
+
+
+@router.get("/stats/artifacts", response_model=ArtifactStats)
+async def get_artifacts_stats(
+    window: Annotated[str, Query(description="Time window, e.g., '24h', '7d'")] = "24h",
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> ArtifactStats:
+    """
+    Aggregate artifact stats for this user/org: counts, bytes, pinned, etc.
+    Backed by MeteringService.get_artifact_stats().
+    """
+    container = current_services()
+    meter = getattr(container, "metering", None)
+    if meter is None:
+        raise HTTPException(status_code=501, detail="Metering service not available")
+
+    raw: dict[str, dict[str, int]] = await meter.get_artifact_stats(
+        user_id=identity.user_id if identity and identity.user_id else None,
+        org_id=identity.org_id if identity and identity.org_id else None,
+        window=window,
+    )
+    # raw: { "json": {"count":..., "bytes":..., "pinned_count":..., "pinned_bytes":...}, ... }
+    return ArtifactStats(root=raw)
+
+
+@router.get("/stats/llm", response_model=LLMStats)
+async def get_stats_llm(
+    window: Annotated[str, Query(description="Time window, e.g., '24h', '7d'")] = "24h",
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> LLMStats:
+    """
+    LLM usage stats: tokens, requests, breakdown by provider/model.
+    Backed by MeteringService.get_llm_stats().
+    """
+    container = current_services()
+    meter = getattr(container, "metering", None)
+    if meter is None:
+        raise HTTPException(status_code=501, detail="Metering service not available")
+
+    raw: dict[str, dict[str, int]] = await meter.get_llm_stats(
+        user_id=identity.user_id if identity and identity.user_id else None,
+        org_id=identity.org_id if identity and identity.org_id else None,
+        window=window,
+    )
+    # raw: { "gpt-4o-mini": {"calls":..., "prompt_tokens":..., "completion_tokens":...}, ... }
+    return LLMStats(root=raw)

aethergraph/api/v1/viz.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from aethergraph.api.v1.deps import RequestIdentity, get_identity
+from aethergraph.api.v1.schemas import (
+    RunVizResponse,
+    VizFigure,
+    VizKind,
+    VizPoint,
+    VizTrack,
+)
+from aethergraph.core.runtime.runtime_services import current_services
+
+router = APIRouter(tags=["viz"])
+
+
+@router.get("/runs/{run_id}/viz", response_model=RunVizResponse)
+async def get_run_viz(
+    run_id: str,
+    viz_kinds: Annotated[
+        str | None,
+        Query(
+            description=(
+                "Comma-separated list of viz kinds to include. "
+                "Options: scalar,vector,matrix,image. "
+                "If omitted, all viz kinds are returned."
+            )
+        ),
+    ] = None,
+    identity: RequestIdentity = Depends(get_identity),  # noqa: B008
+) -> RunVizResponse:
+    """
+    Aggregate visualization data for a run into figures/tracks for the Vis tab.
+
+    - Uses the EventLog-backed VizService.
+    - Enforces demo scoping via RunManager (client_id).
+    - Returns structured data (scalars, vectors, matrices, image references),
+      not pre-rendered plots.
+    """
+    container = current_services()
+
+    viz_service = getattr(container, "viz_service", None)
+    rm = getattr(container, "run_manager", None)
+    if viz_service is None:
+        raise HTTPException(status_code=500, detail="VizService not available")
+
+    # Demo mode: require RunManager to verify access
+    if identity.mode == "demo" and rm is None:
+        raise HTTPException(status_code=500, detail="RunManager not available")
+
+    # Parse viz kinds filter [optional]
+    kinds_filter: list[VizKind] | None = None
+    if viz_kinds:
+        raw = [k.strip().lower() for k in viz_kinds.split(",") if k.strip()]
+        allowed: set[str] = {"scalar", "vector", "matrix", "image"}
+        bad = [k for k in raw if k not in allowed]
+        if bad:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid viz kinds: {', '.join(bad)}; allowed: {', '.join(sorted(allowed))}",
+            )
+        kinds_filter = raw  # type: ignore[assignment]
+
+    # Query raw viz events for this run from VizService
+    rows = await viz_service.query_run(run_id, kinds=kinds_filter)
+
+    # Group into figures/tracks/points
+    # Key: (figure_id, track_id, viz_kind, node_id)
+    track_map: dict[tuple[str | None, str, str, str | None], dict[str, Any]] = {}
+    for row in rows:
+        data: dict[str, Any] = row.get("data") or {}
+        viz_kind: str = data.get("viz_kind")
+        track_id: str = data.get("track_id")
+        figure_id: str | None = data.get("figure_id")
+        node_id: str | None = data.get("node_id")
+        step = data.get("step")
+
+        if track_id is None or viz_kind is None or step is None:
+            # skip malformed events
+            continue
+
+        key = (figure_id, track_id, viz_kind, node_id)
+        agg = track_map.get(key)
+        if agg is None:
+            agg = {
+                "figure_id": figure_id,
+                "track_id": track_id,
+                "viz_kind": viz_kind,
+                "node_id": node_id,
+                "mode": data.get("mode", "append"),
+                "meta": data.get("meta") or {},
+                "points": [],
+            }
+            track_map[key] = agg
+
+        # Mode/meta: keep the first one, but allow later events to update if you want
+        # For now we just keep existing 'mode' and 'meta' if already set.
+
+        # Build point
+        ts_str: str | None = row.get("ts") or data.get("created_at")
+        created_at: datetime | None = None
+        if ts_str:
+            try:
+                created_at = datetime.fromisoformat(ts_str)
+            except Exception:
+                created_at = None
+
+        point = VizPoint(
+            step=int(step),
+            value=data.get("value"),
+            vector=data.get("vector"),
+            matrix=data.get("matrix"),
+            artifact_id=data.get("artifact_id"),
+            created_at=created_at,
+        )
+        agg["points"].append(point)
+
+    # Build figures from grouping
+    figures_map: dict[str | None, list[VizTrack]] = {}
+
+    for (fig_id, track_id, _, node_id), agg in track_map.items():
+        points: list[VizPoint] = agg["points"]
+        # Sort points by step (and then by created_at as tiebreaker)
+        points.sort(key=lambda p: (p.step, p.created_at or datetime.min))
+
+        track = VizTrack(
+            track_id=track_id,
+            figure_id=fig_id,
+            node_id=node_id,
+            viz_kind=agg["viz_kind"],
+            mode=agg["mode"],
+            meta=agg["meta"],
+            points=points,
+        )
+
+        lst = figures_map.setdefault(fig_id, [])
+        lst.append(track)
+
+    # Sort tracks within each figure by track_id for stability
+    figures: list[VizFigure] = []
+    for fig_id, tracks in figures_map.items():
+        tracks.sort(key=lambda t: t.track_id)
+        figures.append(VizFigure(figure_id=fig_id, tracks=tracks))
+
+    # Sort figures: put named figures first, then the Node/default one
+    figures.sort(key=lambda f: (f.figure_id is None, f.figure_id or ""))
+
+    return RunVizResponse(run_id=run_id, figures=figures)