create-windy 0.8.2 → 0.9.1

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

@@ -1,83 +0,0 @@
-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

@@ -1,336 +0,0 @@
-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 .engine_identity import DIRECT_ENGINE_ID
-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,
-        engine_id: str = DIRECT_ENGINE_ID,
-    ) -> None:
-        await self.ready()
-        context = request.reporting
-        values = run_insert_values(
-            run_id,
-            request,
-            created_at,
-            self.retention_days,
-            engine_id,
-        )
-        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 engine_id, 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 = (
-                engine_id,
-                request.operation_key,
-                request.release.release_id,
-                request.trace_id,
-                context.actor_id if context else None,
-            )
-            if (
-                not existing
-                or (
-                    str(existing["engine_id"]),
-                    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()