create-windy 0.4.1 → 0.5.1

package/template/apps/agent-server/src/southwind_agent_server/postgres_report_status.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any
+
+from psycopg import AsyncConnection
+
+from .report_types import NonTerminalRunStatus
+
+
+async def start_or_resume_run(
+    connection: AsyncConnection[dict[str, Any]],
+    run_id: str,
+    started_at: float,
+) -> int:
+    async with connection.transaction():
+        cursor = await connection.execute(
+            """
+            update agent_runtime_report_runs
+            set status = 'running', started_at = coalesce(started_at, %s),
+              updated_at = %s
+            where run_id = %s
+              and status not in ('completed', 'failed', 'cancelled')
+            """,
+            (started_at, started_at, run_id),
+        )
+        if cursor.rowcount != 1:
+            existing = await connection.execute(
+                """
+                select status from agent_runtime_report_runs
+                where run_id = %s
+                """,
+                (run_id,),
+            )
+            if not await existing.fetchone():
+                raise KeyError(run_id)
+            return 0
+        abandoned = await connection.execute(
+            """
+            update agent_runtime_report_attempts
+            set outcome = 'abandoned', finished_at = %s,
+              duration_ms = greatest(0, round((%s - started_at) * 1000))
+            where run_id = %s and outcome = 'running'
+              and finished_at is null
+            """,
+            (started_at, started_at, run_id),
+        )
+        return abandoned.rowcount
+
+
+async def set_nonterminal_run_status(
+    connection: AsyncConnection[dict[str, Any]],
+    run_id: str,
+    status: NonTerminalRunStatus,
+    updated_at: float,
+) -> None:
+    cursor = await connection.execute(
+        """
+        update agent_runtime_report_runs
+        set status = %s, updated_at = %s
+        where run_id = %s
+          and status not in ('completed', 'failed', 'cancelled')
+          and updated_at <= %s
+        """,
+        (status, updated_at, run_id, updated_at),
+    )
+    if cursor.rowcount == 1:
+        return
+    current_cursor = await connection.execute(
+        """
+        select status, updated_at
+        from agent_runtime_report_runs
+        where run_id = %s
+        """,
+        (run_id,),
+    )
+    current = await current_cursor.fetchone()
+    if not current:
+        raise KeyError(run_id)
+    if current["status"] in {"completed", "failed", "cancelled"}:
+        return
+    if float(current["updated_at"]) > updated_at:
+        return
+    raise RuntimeError("Agent Runtime 报表状态更新失败")

package/template/apps/agent-server/src/southwind_agent_server/postgres_report_store.py

@@ -0,0 +1,331 @@
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from typing import Any, Literal, cast
+
+from psycopg import AsyncConnection
+from psycopg.rows import dict_row
+from psycopg_pool import AsyncConnectionPool
+
+from .contracts import StartRunRequest
+from .postgres_report_insert import RUN_INSERT_SQL, run_insert_values
+from .postgres_report_queries import get_run, list_runs
+from .postgres_report_replay import assert_attempt_terminal_replay
+from .postgres_report_status import (
+    set_nonterminal_run_status,
+    start_or_resume_run,
+)
+from .postgres_report_summary import summary
+from .report_metrics import AgentRuntimeMetrics
+from .report_store import AgentRuntimeReportStore
+from .report_types import (
+    AttemptReport,
+    AttemptTerminalOutcome,
+    NonTerminalRunStatus,
+    ReportFilter,
+    UsageFacts,
+    retention_seconds,
+    validate_retention,
+)
+
+type DatabaseConnection = AsyncConnection[dict[str, Any]]
+
+
+class PostgresAgentRuntimeReportStore(AgentRuntimeReportStore):
+    def __init__(
+        self,
+        database_url: str,
+        retention_days: int = 90,
+        *,
+        metrics: AgentRuntimeMetrics | None = None,
+    ) -> None:
+        validate_retention(retention_days)
+        self.retention_days = retention_days
+        self.metrics = metrics or AgentRuntimeMetrics()
+        self._pool = cast(
+            AsyncConnectionPool[DatabaseConnection],
+            AsyncConnectionPool(
+                database_url,
+                min_size=1,
+                max_size=10,
+                open=False,
+                kwargs={"row_factory": dict_row},
+            ),
+        )
+        self._open_lock = asyncio.Lock()
+        self._opened = False
+
+    async def ready(self) -> None:
+        if self._opened:
+            return
+        async with self._open_lock:
+            if not self._opened:
+                await self._pool.open()
+                self._opened = True
+
+    async def ensure_run(
+        self,
+        run_id: str,
+        request: StartRunRequest,
+        created_at: float,
+    ) -> None:
+        await self.ready()
+        context = request.reporting
+        values = run_insert_values(
+            run_id,
+            request,
+            created_at,
+            self.retention_days,
+        )
+        async with self._pool.connection() as connection:
+            await connection.execute(
+                "delete from agent_runtime_report_runs where expires_at <= %s",
+                (time.time(),),
+            )
+            cursor = await connection.execute(RUN_INSERT_SQL, values)
+            if cursor.rowcount == 1:
+                return
+            existing_cursor = await connection.execute(
+                """
+                select operation_key, release_id, trace_id, actor_id
+                from agent_runtime_report_runs where run_id = %s
+                """,
+                (run_id,),
+            )
+            existing = await existing_cursor.fetchone()
+            identity = (
+                request.operation_key,
+                request.release.release_id,
+                request.trace_id,
+                context.actor_id if context else None,
+            )
+            if (
+                not existing
+                or (
+                    str(existing["operation_key"]),
+                    str(existing["release_id"]),
+                    str(existing["trace_id"]),
+                    existing["actor_id"],
+                )
+                != identity
+            ):
+                raise ValueError("Agent Runtime 报表 Run 身份冲突")
+
+    async def start_run(self, run_id: str, started_at: float) -> None:
+        await self.ready()
+        async with self._pool.connection() as connection:
+            abandoned = await start_or_resume_run(connection, run_id, started_at)
+        for _ in range(abandoned):
+            self.metrics.observe_attempt("abandoned", UsageFacts())
+
+    async def finish_run(
+        self,
+        run_id: str,
+        status: Literal["completed", "failed", "cancelled"],
+        finished_at: float,
+        safe_error_code: str | None = None,
+    ) -> None:
+        await self.ready()
+        observed = False
+        async with self._pool.connection() as connection:
+            cursor = await connection.execute(
+                """
+                update agent_runtime_report_runs
+                set status = %s, safe_error_code = %s, finished_at = %s,
+                  duration_ms = greatest(
+                    0, round((%s - coalesce(started_at, created_at)) * 1000)
+                  ),
+                  updated_at = %s, expires_at = %s
+                where run_id = %s
+                  and status not in ('completed', 'failed', 'cancelled')
+                """,
+                (
+                    status,
+                    safe_error_code,
+                    finished_at,
+                    finished_at,
+                    finished_at,
+                    finished_at + retention_seconds(self.retention_days),
+                    run_id,
+                ),
+            )
+            observed = cursor.rowcount == 1
+            if not observed:
+                current_cursor = await connection.execute(
+                    "select status from agent_runtime_report_runs where run_id = %s",
+                    (run_id,),
+                )
+                current = await current_cursor.fetchone()
+                if not current:
+                    raise KeyError(run_id)
+                if current["status"] != status:
+                    raise ValueError("Agent Runtime 报表终态冲突")
+        if observed:
+            self.metrics.observe_run(status)
+
+    async def set_run_status(
+        self,
+        run_id: str,
+        status: NonTerminalRunStatus,
+        updated_at: float,
+    ) -> None:
+        await self.ready()
+        async with self._pool.connection() as connection:
+            await set_nonterminal_run_status(connection, run_id, status, updated_at)
+
+    async def start_attempt(
+        self,
+        run_id: str,
+        tool_round: int,
+        deployment_key: str,
+        requested_model: str,
+        started_at: float,
+    ) -> AttemptReport:
+        await self.ready()
+        attempt_id = f"attempt_{uuid.uuid4().hex}"
+        async with self._pool.connection() as connection:
+            async with connection.transaction():
+                await connection.execute(
+                    "select pg_advisory_xact_lock(hashtext(%s))",
+                    (run_id,),
+                )
+                cursor = await connection.execute(
+                    """
+                    select coalesce(max(sequence), 0) + 1 as sequence
+                    from agent_runtime_report_attempts where run_id = %s
+                    """,
+                    (run_id,),
+                )
+                row = await cursor.fetchone()
+                sequence = int(row["sequence"]) if row else 1
+                await connection.execute(
+                    """
+                    insert into agent_runtime_report_attempts (
+                      attempt_id, run_id, sequence, tool_round,
+                      deployment_key, requested_model, outcome,
+                      cache_status, usage_source, started_at
+                    ) values (
+                      %s, %s, %s, %s, %s, %s,
+                      'running', 'unknown', 'unknown', %s
+                    )
+                    """,
+                    (
+                        attempt_id,
+                        run_id,
+                        sequence,
+                        tool_round,
+                        deployment_key,
+                        requested_model,
+                        started_at,
+                    ),
+                )
+        return AttemptReport(
+            attempt_id=attempt_id,
+            run_id=run_id,
+            sequence=sequence,
+            tool_round=tool_round,
+            deployment_key=deployment_key,
+            requested_model=requested_model,
+            reported_model=None,
+            outcome="running",
+            usage=UsageFacts(),
+            duration_ms=None,
+            safe_error_code=None,
+            started_at=started_at,
+            finished_at=None,
+        )
+
+    async def finish_attempt(
+        self,
+        attempt_id: str,
+        outcome: AttemptTerminalOutcome,
+        usage: UsageFacts,
+        finished_at: float,
+        reported_model: str | None = None,
+        safe_error_code: str | None = None,
+    ) -> None:
+        await self.ready()
+        values = (
+            outcome,
+            usage.cache_status,
+            usage.source,
+            usage.input_tokens,
+            usage.output_tokens,
+            usage.cached_input_tokens,
+            usage.reasoning_tokens,
+            usage.total_tokens,
+            usage.first_token_latency_ms,
+            reported_model,
+            safe_error_code,
+            finished_at,
+            finished_at,
+            attempt_id,
+        )
+        async with self._pool.connection() as connection:
+            cursor = await connection.execute(
+                """
+                update agent_runtime_report_attempts set
+                  outcome = %s, cache_status = %s, usage_source = %s,
+                  input_tokens = %s, output_tokens = %s,
+                  cached_input_tokens = %s, reasoning_tokens = %s,
+                  total_tokens = %s, first_token_latency_ms = %s,
+                  reported_model = %s, safe_error_code = %s,
+                  duration_ms = greatest(0, round((%s - started_at) * 1000)),
+                  finished_at = %s
+                where attempt_id = %s and finished_at is null
+                """,
+                values,
+            )
+            observed = cursor.rowcount == 1
+            if not observed:
+                current_cursor = await connection.execute(
+                    """
+                    select outcome, cache_status, usage_source,
+                      input_tokens, output_tokens, cached_input_tokens,
+                      reasoning_tokens, total_tokens, first_token_latency_ms,
+                      reported_model, safe_error_code
+                    from agent_runtime_report_attempts
+                    where attempt_id = %s
+                    """,
+                    (attempt_id,),
+                )
+                current = await current_cursor.fetchone()
+                if not current:
+                    raise KeyError(attempt_id)
+                assert_attempt_terminal_replay(
+                    current,
+                    outcome,
+                    usage,
+                    reported_model,
+                    safe_error_code,
+                )
+        if observed:
+            self.metrics.observe_attempt(outcome, usage)
+
+    async def summary(self, query: ReportFilter) -> dict[str, object]:
+        await self.ready()
+        return await summary(
+            self._pool,
+            query,
+            self.retention_days,
+            time.time(),
+        )
+
+    async def list_runs(
+        self,
+        query: ReportFilter,
+        page: int,
+        page_size: int,
+    ) -> dict[str, object]:
+        await self.ready()
+        return await list_runs(self._pool, query, page, page_size, time.time())
+
+    async def get_run(self, run_id: str) -> dict[str, object] | None:
+        await self.ready()
+        return await get_run(self._pool, run_id, time.time())
+
+    async def close(self) -> None:
+        if self._opened:
+            await self._pool.close()