agentengine-sdk-python 0.8.5__py3-none-any.whl → 0.8.6__py3-none-any.whl

ksadk/sessions/_postgres_checkpoint_read.py

@@ -0,0 +1,323 @@
+"""Snapshot-bound PostgreSQL checkpoint reads and resume audits."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from contextlib import aclosing, nullcontext
+from typing import Any
+
+from ksadk.sessions._checkpoint_resume_audit import CheckpointResumeAudit
+from ksadk.sessions._postgres_tables import KSADK_PG_EVENTS_TABLE, KSADK_PG_SESSIONS_TABLE
+from ksadk.sessions.base import (
+    CheckpointEventQuery,
+    Session,
+    SessionEvent,
+    SessionEventQuery,
+    checkpoint_creation_identity,
+    checkpoint_resume_identity,
+)
+from ksadk.sessions.errors import HistoryProjectionBudgetExceeded
+from ksadk.sessions.history_budget import CURRENT_HISTORY_READ_BUDGET
+
+
+class _PostgresCheckpointReadMixin:
+    async def scan_checkpoint_events(self, query: CheckpointEventQuery) -> list[SessionEvent]:
+        if query.limit < 1 or query.limit > 50:
+            raise ValueError("checkpoint scan limit must be between 1 and 50")
+        return await self._scan_checkpoint_events_with_connection(None, query)
+
+    async def iter_resume_related_event_pages(
+        self,
+        session_id: str,
+        *,
+        page_size: int = 256,
+        expected_session: Session | None = None,
+    ) -> AsyncIterator[list[SessionEvent]]:
+        """Scan only resume facts by sequence in one read-only snapshot."""
+        await self._ensure_schema()
+        kinds = [
+            "run_checkpoint",
+            "run_resume",
+            "runtime_resume",
+            "continuation.created",
+            "continuation.resumed",
+        ]
+        async with self._connection() as connection:
+            async with connection.transaction(isolation="repeatable_read", readonly=True):
+                if expected_session is not None:
+                    from ksadk.sessions.errors import HistoryReloadRequired
+
+                    owner = await connection.fetchrow(
+                        f"SELECT agent_id,user_id,created_at FROM {KSADK_PG_SESSIONS_TABLE} "
+                        "WHERE namespace=$1 AND id=$2",
+                        self.namespace,
+                        session_id,
+                    )
+                    if (
+                        owner is None
+                        or owner["agent_id"] != expected_session.agent_id
+                        or owner["user_id"] != expected_session.user_id
+                        or float(owner["created_at"]) != expected_session.created_at
+                    ):
+                        raise HistoryReloadRequired("Checkpoint session changed during lookup")
+                upper = int(
+                    await connection.fetchval(
+                        f"SELECT COALESCE(MAX(seq_id),0) FROM {KSADK_PG_EVENTS_TABLE} "
+                        "WHERE namespace=$1 AND session_id=$2",
+                        self.namespace,
+                        session_id,
+                    )
+                    or 0
+                )
+                count = int(
+                    await connection.fetchval(
+                        f"SELECT COUNT(*) FROM {KSADK_PG_EVENTS_TABLE} "
+                        "WHERE namespace=$1 AND session_id=$2 AND event_type=ANY($3::text[]) "
+                        "AND seq_id<=$4",
+                        self.namespace,
+                        session_id,
+                        kinds,
+                        upper,
+                    )
+                    or 0
+                )
+                if count > 8192:
+                    raise HistoryProjectionBudgetExceeded(
+                        "Checkpoint lookup exceeds 8192 related events"
+                    )
+                cursor = 0
+                used = 0
+                while True:
+                    candidates = (
+                        f"FROM {KSADK_PG_EVENTS_TABLE} WHERE namespace=$1 AND session_id=$2 "
+                        "AND event_type=ANY($3::text[]) AND seq_id>$4 AND seq_id<=$5 "
+                        "ORDER BY seq_id,id LIMIT $6"
+                    )
+                    args = (self.namespace, session_id, kinds, cursor, upper, page_size)
+                    size = int(
+                        await connection.fetchval(
+                            "SELECT COALESCE(SUM(octet_length(content_json::text)+"
+                            "octet_length(state_delta_json::text)+"
+                            "octet_length(metadata_json::text)+"
+                            "octet_length(to_jsonb(id)::text)+"
+                            "octet_length(to_jsonb(session_id)::text)+"
+                            "octet_length(to_jsonb(author)::text)+"
+                            "octet_length(to_jsonb(event_type)::text)+"
+                            "COALESCE(octet_length(to_jsonb(invocation_id)::text),0)+256),0) "
+                            "FROM (SELECT id,session_id,author,event_type,invocation_id,"
+                            "content_json,state_delta_json,metadata_json "
+                            + candidates
+                            + ") AS resume_candidates",
+                            *args,
+                        )
+                        or 0
+                    )
+                    if used + size > 16 * 1024 * 1024:
+                        raise HistoryProjectionBudgetExceeded(
+                            "Checkpoint lookup exceeds 16 MiB of related events"
+                        )
+                    rows = await connection.fetch(
+                        "SELECT id,session_id,author,event_type,content_json,timestamp,"
+                        "state_delta_json,seq_id,invocation_id,metadata_json " + candidates,
+                        *args,
+                    )
+                    if not rows:
+                        break
+                    yield [self._event_from_row(row) for row in rows]
+                    used += size
+                    cursor = int(rows[-1]["seq_id"])
+                    if len(rows) < page_size:
+                        break
+
+    async def _scan_checkpoint_events_with_connection(
+        self,
+        connection: Any | None,
+        query: CheckpointEventQuery,
+        cursor: tuple[float, str, int, str] | None = None,
+    ) -> list[SessionEvent]:
+        event_query = SessionEventQuery(
+            session_ids=query.session_ids,
+            agent_id=query.agent_id,
+            event_types=["run_checkpoint", "continuation.created"],
+            checkpoint_ids=query.checkpoint_ids,
+            run_id=query.run_id,
+            offset=query.offset,
+            limit=query.limit,
+            from_start=True,
+        )
+        if query.framework is None and connection is None:
+            return await self.query_events(event_query)
+        if connection is None:
+            async with self._connection() as owned:
+                bounded = CURRENT_HISTORY_READ_BUDGET.get() is not None
+                async with (
+                    owned.transaction(isolation="repeatable_read", readonly=True)
+                    if bounded
+                    else nullcontext()
+                ):
+                    return await self._scan_checkpoint_events_with_connection(
+                        owned,
+                        query,
+                        cursor,
+                    )
+        await self._ensure_schema()
+        clauses, params = self._batch_event_where(event_query)
+        if query.framework is not None:
+            params.append(query.framework.lower())
+            clauses.append(
+                "(lower(event_row.metadata_json->>'framework')="
+                f"${len(params)}"
+                " OR (event_row.event_type='continuation.created'"
+                " AND lower(event_row.content_json->'runtime_event'->'source'->>'framework')="
+                f"${len(params)}))"
+            )
+        if cursor is not None:
+            placeholders = []
+            for value in cursor:
+                params.append(value)
+                placeholders.append(f"${len(params)}")
+            clauses.append(
+                "(event_row.timestamp,event_row.session_id,event_row.seq_id,event_row.id) > "
+                f"({','.join(placeholders)})"
+            )
+        params.extend([query.limit, query.offset])
+        candidates = (
+            f"FROM {KSADK_PG_EVENTS_TABLE} event_row "
+            f"JOIN {KSADK_PG_SESSIONS_TABLE} session_row "
+            "ON session_row.namespace=event_row.namespace "
+            "AND session_row.id=event_row.session_id "
+            f"WHERE {' AND '.join(clauses)} ORDER BY event_row.timestamp,event_row.session_id,"
+            f"event_row.seq_id,event_row.id LIMIT ${len(params) - 1} OFFSET ${len(params)}"
+        )
+        await self._precheck_history_body(
+            connection,
+            "SELECT event_row.content_json,event_row.state_delta_json,"
+            "event_row.metadata_json " + candidates,
+            params,
+        )
+        rows = await connection.fetch(
+            "SELECT event_row.id,event_row.session_id,event_row.author,event_row.event_type,"
+            "event_row.content_json,event_row.timestamp,event_row.state_delta_json,"
+            "event_row.seq_id,event_row.invocation_id,event_row.metadata_json " + candidates,
+            *params,
+        )
+        return [self._event_from_row(row) for row in rows]
+
+    async def iter_checkpoint_event_chunks(
+        self, query: CheckpointEventQuery
+    ) -> AsyncIterator[list[SessionEvent]]:
+        if query.limit < 1 or query.limit > 50:
+            raise ValueError("checkpoint scan limit must be between 1 and 50")
+        await self._ensure_schema()
+        async with self._connection() as connection:
+            async with connection.transaction(isolation="repeatable_read", readonly=True):
+                token = self._checkpoint_snapshot_connection.set(connection)
+                try:
+                    cursor: tuple[float, str, int, str] | None = None
+                    first_page = True
+                    while True:
+                        batch = await self._scan_checkpoint_events_with_connection(
+                            connection,
+                            CheckpointEventQuery(
+                                **{
+                                    **query.__dict__,
+                                    "offset": query.offset if first_page else 0,
+                                }
+                            ),
+                            cursor,
+                        )
+                        if not batch:
+                            break
+                        yield batch
+                        if len(batch) < query.limit:
+                            break
+                        last = batch[-1]
+                        cursor = (
+                            last.timestamp,
+                            last.session_id,
+                            last.seq_id,
+                            last.id,
+                        )
+                        first_page = False
+                finally:
+                    self._checkpoint_snapshot_connection.reset(token)
+
+    async def get_checkpoint_lookup_stats(
+        self, session_id: str, run_id: str, checkpoint_id: str
+    ) -> dict[str, object]:
+        candidate = None
+        max_seq_id = 0
+        audit = CheckpointResumeAudit()
+        async with asyncio.timeout(self.db_budget.write_operation_seconds):
+            async with aclosing(self.iter_resume_related_event_pages(session_id)) as pages:
+                async for page in pages:
+                    for event in page:
+                        creation = checkpoint_creation_identity(event)
+                        if event.event_type == "run_checkpoint":
+                            metadata = event.metadata or {}
+                            if str(metadata.get("run_id") or "") != run_id:
+                                continue
+                            max_seq_id = max(max_seq_id, event.seq_id)
+                            if str(metadata.get("checkpoint_id") or "") == checkpoint_id:
+                                candidate = event
+                        elif creation is not None:
+                            if creation == (run_id, checkpoint_id):
+                                max_seq_id = max(max_seq_id, event.seq_id)
+                                candidate = event
+                        else:
+                            identity = checkpoint_resume_identity(event)
+                            if identity is not None and identity[:2] == (run_id, checkpoint_id):
+                                audit.record(event, identity)
+        return {
+            "candidate": candidate,
+            "max_seq_id": max_seq_id,
+            "resume_count": audit["resume_count"],
+            "last_resumed_at": audit["last_resumed_at"],
+        }
+
+    async def get_checkpoint_stats(self, keys: list[tuple[str, str, str]]) -> dict[str, object]:
+        from ksadk.sessions._postgres_checkpoint_stats import get_checkpoint_stats
+
+        if len(keys) > 50:
+            raise ValueError("checkpoint stats batch cannot exceed 50 keys")
+        if not keys:
+            return {"audits": {}, "latest_seq_ids": {}}
+        await self._ensure_schema()
+        active = self._checkpoint_snapshot_connection.get()
+        async with asyncio.timeout(self.db_budget.write_operation_seconds):
+            async with self._connection() if active is None else nullcontext(active) as connection:
+                async with (
+                    connection.transaction(isolation="repeatable_read", readonly=True)
+                    if active is None
+                    else nullcontext()
+                ):
+                    # The master aggregation validates every known carrier before
+                    # filtering identity. Bound its duplicated per-key JSON input
+                    # in the same snapshot, preserving fail-loud audit semantics.
+                    sessions = [key[0] for key in dict.fromkeys(keys)]
+                    sizes = await connection.fetchrow(
+                        f"SELECT COUNT(*) AS event_count, COALESCE(SUM("
+                        "octet_length(event_row.content_json::text)+"
+                        "octet_length(event_row.metadata_json::text)+1024),0) AS body_bytes "
+                        f"FROM {KSADK_PG_EVENTS_TABLE} event_row "
+                        "JOIN unnest($2::text[]) requested(session_id) "
+                        "ON event_row.session_id=requested.session_id "
+                        "WHERE event_row.namespace=$1 AND event_row.event_type IN "
+                        "('run_resume','runtime_resume','continuation.resumed','continuation.created')",
+                        self.namespace,
+                        sessions,
+                    )
+                    size = int(sizes["body_bytes"])
+                    if int(sizes["event_count"]) > 8192 or size > 16 * 1024 * 1024:
+                        raise HistoryProjectionBudgetExceeded(
+                            "Checkpoint audit exceeds related-event budget"
+                        )
+                    budget = CURRENT_HISTORY_READ_BUDGET.get()
+                    if budget is not None:
+                        budget.account(size)
+                    token = self._checkpoint_snapshot_connection.set(connection)
+                    try:
+                        return await get_checkpoint_stats(self, keys)
+                    finally:
+                        self._checkpoint_snapshot_connection.reset(token)

ksadk/sessions/_postgres_checkpoint_stats.py

@@ -0,0 +1,330 @@
+"""PostgreSQL checkpoint audit aggregation helpers."""
+
+from __future__ import annotations
+
+import json
+import math
+from typing import Any
+
+from ksadk.sessions._checkpoint_resume_audit import CheckpointResumeAudit
+from ksadk.sessions._postgres_tables import KSADK_PG_EVENTS_TABLE
+from ksadk.sessions.base import (
+    SessionEvent,
+    checkpoint_creation_identity,
+    checkpoint_resume_identity,
+)
+
+
+def _raw_session_event(session_id: str, raw_event: object) -> SessionEvent:
+    if isinstance(raw_event, str):
+        try:
+            raw_event = json.loads(raw_event)
+        except (TypeError, ValueError):
+            raw_event = None
+    if not isinstance(raw_event, dict):
+        raise ValueError("canonical checkpoint carrier row is not an object")
+    return SessionEvent(
+        id=str(raw_event.get("id") or ""),
+        session_id=session_id,
+        event_type=str(raw_event.get("event_type") or ""),
+        content=dict(raw_event.get("content") or {}),
+        timestamp=raw_event.get("timestamp", 0.0),
+        seq_id=int(raw_event.get("seq_id") or 0),
+        invocation_id=raw_event.get("invocation_id"),
+        metadata=dict(raw_event.get("metadata") or {}),
+    )
+
+
+def _json_rows(value: object) -> tuple[object, ...]:
+    """Decode asyncpg JSONB aggregates whether codecs return text or lists."""
+
+    if value is None:
+        return ()
+    if isinstance(value, str):
+        try:
+            value = json.loads(value)
+        except (TypeError, ValueError) as error:
+            raise ValueError("canonical checkpoint carrier aggregate is not valid JSON") from error
+    if not isinstance(value, (list, tuple)):
+        raise ValueError("canonical checkpoint carrier aggregate is not an array")
+    return tuple(value)
+
+
+async def get_checkpoint_stats(
+    service: Any, keys: list[tuple[str, str, str]]
+) -> dict[str, object]:
+    if len(keys) > 50:
+        raise ValueError("checkpoint stats batch cannot exceed 50 keys")
+    unique_keys = list(dict.fromkeys(keys))
+    audits = {key: {"resume_count": 0, "last_resumed_at": None} for key in unique_keys}
+    run_keys = list(dict.fromkeys((session_id, run_id) for session_id, run_id, _ in unique_keys))
+    latest = {key: 0 for key in run_keys}
+    if not unique_keys:
+        return {"audits": audits, "latest_seq_ids": latest}
+    await service._ensure_schema()
+    connection = service._checkpoint_snapshot_connection.get()
+    owns_connection = connection is None
+    if owns_connection:
+        connection = await service._pool.acquire()
+    try:
+        audit_rows = await connection.fetch(
+            f"""WITH requested(session_id,run_id,checkpoint_id) AS (
+                SELECT * FROM unnest($2::text[],$3::text[],$4::text[])
+            )
+            SELECT requested.session_id,requested.run_id,requested.checkpoint_id,
+                   MAX(event_row.timestamp) FILTER (
+                     WHERE event_row.event_type IN ('run_resume','runtime_resume')
+                       AND event_row.timestamp > '-Infinity'::double precision
+                       AND event_row.timestamp < 'Infinity'::double precision
+                   ) AS legacy_last_resumed_at,
+                   COUNT(event_row.id) FILTER (
+                     WHERE event_row.event_type IN ('run_resume','runtime_resume')
+                   ) AS legacy_resume_count,
+                   ARRAY_AGG(event_row.timestamp ORDER BY event_row.id) FILTER (
+                     WHERE event_row.event_type='continuation.resumed'
+                   ) AS canonical_carrier_timestamps,
+                   ARRAY_AGG(
+                     COALESCE(
+                       event_row.content_json->'runtime_event'->>'timestamp',
+                       event_row.content_json->'session_event'->'payload'->>'timestamp'
+                     )
+                     ORDER BY event_row.id
+                   ) FILTER (WHERE event_row.event_type='continuation.resumed')
+                   AS canonical_timestamps,
+                   (
+                     SELECT COALESCE(
+                       jsonb_agg(
+                         jsonb_build_object(
+                           'id', resume_row.id,
+                           'event_type', resume_row.event_type,
+                           'content', resume_row.content_json,
+                           'timestamp', resume_row.timestamp,
+                           'seq_id', resume_row.seq_id,
+                           'invocation_id', resume_row.invocation_id,
+                           'metadata', resume_row.metadata_json
+                         ) ORDER BY resume_row.id
+                       ),
+                       '[]'::jsonb
+                     )
+                     FROM {KSADK_PG_EVENTS_TABLE} resume_row
+                     WHERE resume_row.namespace=$1
+                       AND resume_row.session_id=requested.session_id
+                       AND resume_row.event_type IN (
+                         'run_resume','runtime_resume','continuation.resumed'
+                       )
+                   ) AS resume_rows
+            FROM requested
+            LEFT JOIN {KSADK_PG_EVENTS_TABLE} event_row
+              ON event_row.namespace=$1
+             AND event_row.session_id=requested.session_id
+             AND (
+               (
+                 event_row.event_type IN ('run_resume','runtime_resume')
+                 AND event_row.metadata_json->>'run_id'=requested.run_id
+                 AND event_row.metadata_json->>'checkpoint_id'=requested.checkpoint_id
+               )
+               OR (
+                 event_row.event_type='continuation.resumed'
+                 AND COALESCE(
+                   event_row.metadata_json->>'run_id',
+                   event_row.content_json->'runtime_event'->>'run_id',
+                   event_row.content_json->'session_event'->'payload'->>'run_id'
+                 )=requested.run_id
+                 AND COALESCE(
+                   event_row.content_json->'runtime_event'->>'continuation_id',
+                   event_row.content_json->'session_event'->'payload'->>'continuation_id'
+                 )=requested.checkpoint_id
+                 AND COALESCE(
+                   event_row.content_json->'runtime_event'->>'continuation_kind',
+                   event_row.content_json->'session_event'->'payload'->>'continuation_kind'
+                 )='graph_checkpoint'
+               )
+             )
+            GROUP BY requested.session_id,requested.run_id,requested.checkpoint_id""",
+            service.namespace,
+            [key[0] for key in unique_keys],
+            [key[1] for key in unique_keys],
+            [key[2] for key in unique_keys],
+        )
+        latest_rows = await connection.fetch(
+            f"""WITH requested(session_id,run_id) AS (
+                SELECT * FROM unnest($2::text[],$3::text[])
+            )
+            SELECT requested.session_id,requested.run_id,
+                   COALESCE(MAX(event_row.seq_id),0) AS latest_seq_id,
+                   (
+                     SELECT COALESCE(
+                       jsonb_agg(
+                         jsonb_build_object(
+                           'id', creation_row.id,
+                           'event_type', creation_row.event_type,
+                           'content', creation_row.content_json,
+                           'timestamp', creation_row.timestamp,
+                           'seq_id', creation_row.seq_id,
+                           'invocation_id', creation_row.invocation_id,
+                           'metadata', creation_row.metadata_json
+                         ) ORDER BY creation_row.id
+                       ),
+                       '[]'::jsonb
+                     )
+                     FROM {KSADK_PG_EVENTS_TABLE} creation_row
+                     WHERE creation_row.namespace=$1
+                       AND creation_row.session_id=requested.session_id
+                       AND creation_row.event_type='continuation.created'
+                   ) AS canonical_creation_rows
+            FROM requested
+            LEFT JOIN {KSADK_PG_EVENTS_TABLE} event_row
+              ON event_row.namespace=$1
+             AND event_row.session_id=requested.session_id
+             AND (
+               (
+                 event_row.event_type='run_checkpoint'
+                 AND event_row.metadata_json->>'run_id'=requested.run_id
+               )
+               OR (
+                 event_row.event_type='continuation.created'
+                 AND COALESCE(
+                   event_row.metadata_json->>'run_id',
+                   event_row.content_json->'runtime_event'->>'run_id',
+                   event_row.content_json->'session_event'->'payload'->>'run_id'
+                 )=requested.run_id
+                 AND COALESCE(
+                   event_row.content_json->'runtime_event'->>'continuation_kind',
+                   event_row.content_json->'session_event'->'payload'->>'continuation_kind'
+                 )='graph_checkpoint'
+               )
+             )
+            GROUP BY requested.session_id,requested.run_id""",
+            service.namespace,
+            [key[0] for key in run_keys],
+            [key[1] for key in run_keys],
+        )
+    finally:
+        if owns_connection:
+            await service._pool.release(connection)
+    for row in audit_rows:
+        # Live SQL returns complete identities for both carrier families.
+        # Validate known canonical rows even when they target another checkpoint.
+        if row.get("resume_rows") is not None:
+            audit = CheckpointResumeAudit()
+            for raw_event in _json_rows(row["resume_rows"]):
+                event = _raw_session_event(str(row["session_id"]), raw_event)
+                identity = checkpoint_resume_identity(event)
+                if identity is not None and identity[:2] == (row["run_id"], row["checkpoint_id"]):
+                    audit.record(event, identity)
+            audits[(row["session_id"], row["run_id"], row["checkpoint_id"])] = audit
+            continue
+        # Validate every known canonical resume carrier in the session before
+        # applying the identity filter above.  The SQL join intentionally
+        # narrows counts to the requested checkpoint, but that must not hide a
+        # corrupt known carrier from the same fail-loud policy used by REST,
+        # in-memory, and SQLite paths.
+        canonical_rows_value = row.get("canonical_resume_rows")
+        canonical_rows = (
+            _json_rows(canonical_rows_value) if canonical_rows_value is not None else None
+        )
+        resume_count = int(
+            row.get("legacy_resume_count", row.get("resume_count", 0)) or 0
+        )
+        canonical_timestamps: list[float] = []
+        for raw_event in canonical_rows or ():
+            event = _raw_session_event(str(row["session_id"]), raw_event)
+            identity = checkpoint_resume_identity(event)
+            if identity is None or identity[:2] != (
+                str(row["run_id"]),
+                str(row["checkpoint_id"]),
+            ):
+                continue
+            resume_count += 1
+            canonical_timestamps.append(identity[2])
+        # Keep payload timestamp parsing outside SQL.  Canonical rows are
+        # user-provided JSON and may carry malformed values (including
+        # overflowed exponents); attempting a direct PostgreSQL float cast
+        # would abort the whole stats query.  Legacy carrier timestamps
+        # remain covered by the aggregate above.
+        last_resumed_at = row["legacy_last_resumed_at"]
+        try:
+            last_resumed_at = float(last_resumed_at)
+        except (TypeError, ValueError):
+            last_resumed_at = None
+        if last_resumed_at is not None and not math.isfinite(last_resumed_at):
+            last_resumed_at = None
+        for candidate in canonical_timestamps:
+            last_resumed_at = max(last_resumed_at or candidate, candidate)
+        # Older fake/compatibility rows may not expose canonical_resume_rows;
+        # retain their payload-timestamp precedence fallback. Live PostgreSQL
+        # always returns canonical_resume_rows from the correlated subquery.
+        fallback_pairs = (
+            zip(
+                row.get("canonical_carrier_timestamps") or (),
+                row.get("canonical_timestamps") or row.get("canonical_payloads") or (),
+            )
+            if canonical_rows is None
+            else ()
+        )
+        for carrier_timestamp, raw_value in fallback_pairs:
+            counted_identity = False
+            # Compatibility fakes from the pre-integrity SQL shape return
+            # canonical payload objects rather than extracted timestamps.
+            # Reconstruct a complete carrier identity before validating it.
+            if isinstance(raw_value, str):
+                import json
+
+                try:
+                    raw_value = json.loads(raw_value)
+                except (TypeError, ValueError):
+                    raw_value = None
+            if isinstance(raw_value, dict):
+                from ksadk.events.canonical_store import canonical_storage_id
+
+                payload = dict(raw_value)
+                raw_timestamp = payload.get("timestamp")
+                event = SessionEvent(
+                    id=canonical_storage_id(
+                        str(row["session_id"]), str(payload.get("event_id") or "")
+                    ),
+                    session_id=str(row["session_id"]),
+                    event_type=str(payload.get("event_type") or ""),
+                    content={"runtime_event": payload},
+                    timestamp=carrier_timestamp,
+                    seq_id=int(payload.get("seq") or 0),
+                    metadata={"canonical_event_id": str(payload.get("event_id") or "")},
+                )
+                identity = checkpoint_resume_identity(event)
+                if identity is None or identity[:2] != (
+                    str(row["run_id"]),
+                    str(row["checkpoint_id"]),
+                ):
+                    continue
+                resume_count += 1
+                counted_identity = True
+                raw_timestamp = identity[2]
+            else:
+                raw_timestamp = raw_value
+            try:
+                carrier = float(carrier_timestamp)
+            except (TypeError, ValueError):
+                carrier = None
+            if carrier is not None and not math.isfinite(carrier):
+                carrier = None
+            try:
+                candidate = float(raw_timestamp)
+            except (TypeError, ValueError):
+                candidate = carrier
+            if candidate is None or not math.isfinite(candidate):
+                candidate = carrier
+            if candidate is None:
+                continue
+            if not counted_identity:
+                resume_count += 1
+            last_resumed_at = max(last_resumed_at or candidate, candidate)
+        audits[(row["session_id"], row["run_id"], row["checkpoint_id"])] = {
+            "resume_count": resume_count,
+            "last_resumed_at": last_resumed_at,
+        }
+    for row in latest_rows:
+        for raw_event in _json_rows(row.get("canonical_creation_rows")):
+            event = _raw_session_event(str(row["session_id"]), raw_event)
+            checkpoint_creation_identity(event)
+        latest[(row["session_id"], row["run_id"])] = int(row["latest_seq_id"] or 0)
+    return {"audits": audits, "latest_seq_ids": latest}