create-windy 0.8.2 → 0.9.1

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

@@ -1,304 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from psycopg import AsyncConnection
-from psycopg_pool import AsyncConnectionPool
-
-from .postgres_report_queries import (
-    attempt_filter_clause,
-    filter_clause,
-)
-from .report_types import ReportFilter, iso
-
-type DatabaseConnection = AsyncConnection[dict[str, Any]]
-type DatabasePool = AsyncConnectionPool[DatabaseConnection]
-
-
-async def summary(
-    pool: DatabasePool,
-    query: ReportFilter,
-    retention_days: int,
-    generated_at: float,
-) -> dict[str, object]:
-    run_clause, run_parameters = filter_clause(query, generated_at, "r")
-    attempt_clause, attempt_parameters = attempt_filter_clause(
-        query,
-        generated_at,
-    )
-    async with pool.connection() as connection:
-        run_row = await fetch_one(
-            connection,
-            f"""
-            select count(*) as total,
-              count(*) filter (where r.status = 'completed') as completed,
-              count(*) filter (where r.status = 'failed') as failed,
-              count(*) filter (where r.status = 'cancelled') as cancelled,
-              min(r.created_at) as available_from
-            from agent_runtime_report_runs r {run_clause}
-            """,
-            run_parameters,
-        )
-        attempt_row = await fetch_one(
-            connection,
-            f"""
-            select count(*) as attempts,
-              min(a.started_at) as available_from,
-              count(*) filter (where a.cache_status = 'hit') as cache_hit,
-              count(*) filter (where a.cache_status = 'miss') as cache_miss,
-              count(*) filter (where a.cache_status = 'unknown') as cache_unknown,
-              count(*) filter (
-                where a.total_tokens is not null
-              ) as known_total_tokens,
-              sum(a.input_tokens) as input_tokens,
-              sum(a.output_tokens) as output_tokens,
-              sum(a.cached_input_tokens) as cached_input_tokens,
-              sum(a.reasoning_tokens) as reasoning_tokens,
-              sum(a.total_tokens) as total_tokens,
-              coalesce(sum(a.input_tokens) filter (
-                where a.input_tokens is not null
-                  and a.cached_input_tokens is not null
-              ), 0) as paired_input_tokens,
-              coalesce(sum(a.cached_input_tokens) filter (
-                where a.input_tokens is not null
-                  and a.cached_input_tokens is not null
-              ), 0) as paired_cached_tokens
-            from agent_runtime_report_attempts a
-            join agent_runtime_report_runs r on r.run_id = a.run_id
-            {attempt_clause}
-            """,
-            attempt_parameters,
-        )
-        model_rows = await fetch_all(
-            connection,
-            f"""
-            select a.deployment_key,
-              coalesce(a.reported_model, a.requested_model) as model,
-              count(*) as attempts,
-              sum(a.input_tokens) as input_tokens,
-              sum(a.output_tokens) as output_tokens,
-              sum(a.cached_input_tokens) as cached_input_tokens,
-              sum(a.reasoning_tokens) as reasoning_tokens,
-              sum(a.total_tokens) as total_tokens,
-              count(*) filter (
-                where a.usage_source = 'unknown'
-              ) as unknown_usage_count
-            from agent_runtime_report_attempts a
-            join agent_runtime_report_runs r on r.run_id = a.run_id
-            {attempt_clause}
-            group by a.deployment_key,
-              coalesce(a.reported_model, a.requested_model)
-            order by a.deployment_key,
-              coalesce(a.reported_model, a.requested_model)
-            """,
-            attempt_parameters,
-        )
-        activity_rows = await fetch_all(
-            connection,
-            f"""
-            with run_activity as (
-              select to_char(
-                  to_timestamp(r.created_at) at time zone 'UTC',
-                  'YYYY-MM-DD'
-                ) as date,
-                count(*) as runs,
-                count(*) filter (
-                  where r.status = 'completed'
-                ) as completed,
-                count(*) filter (where r.status = 'failed') as failed
-              from agent_runtime_report_runs r
-              {run_clause}
-              group by 1
-            ),
-            attempt_activity as (
-              select to_char(
-                  to_timestamp(a.started_at) at time zone 'UTC',
-                  'YYYY-MM-DD'
-                ) as date,
-                count(*) as attempts,
-                count(a.total_tokens) as known_token_attempts,
-                sum(a.total_tokens) as total_tokens
-              from agent_runtime_report_attempts a
-              join agent_runtime_report_runs r on r.run_id = a.run_id
-              {attempt_clause}
-              group by 1
-            ),
-            activity_dates as (
-              select date from run_activity
-              union
-              select date from attempt_activity
-            )
-            select d.date,
-              coalesce(ra.runs, 0) as runs,
-              coalesce(ra.completed, 0) as completed,
-              coalesce(ra.failed, 0) as failed,
-              coalesce(aa.attempts, 0) as attempts,
-              aa.total_tokens
-            from activity_dates d
-            left join run_activity ra on ra.date = d.date
-            left join attempt_activity aa on aa.date = d.date
-            order by d.date
-            """,
-            (*run_parameters, *attempt_parameters),
-        )
-    return present_summary(
-        run_row,
-        attempt_row,
-        model_rows,
-        activity_rows,
-        retention_days,
-        generated_at,
-    )
-
-
-def present_summary(
-    run: dict[str, Any],
-    attempt: dict[str, Any],
-    models: list[dict[str, Any]],
-    activity: list[dict[str, Any]],
-    retention_days: int,
-    generated_at: float,
-) -> dict[str, object]:
-    total = integer(run, "total")
-    completed = integer(run, "completed")
-    failed = integer(run, "failed")
-    cancelled = integer(run, "cancelled")
-    attempts = integer(attempt, "attempts")
-    cache_hit = integer(attempt, "cache_hit")
-    cache_miss = integer(attempt, "cache_miss")
-    paired_input = integer(attempt, "paired_input_tokens")
-    available_values = [
-        value
-        for value in (
-            optional_float(run, "available_from"),
-            optional_float(attempt, "available_from"),
-        )
-        if value is not None
-    ]
-    return {
-        "generatedAt": iso(generated_at),
-        "reportingAvailableFrom": iso(
-            min(available_values) if available_values else None
-        ),
-        "retentionDays": retention_days,
-        "runs": {
-            "total": total,
-            "completed": completed,
-            "failed": failed,
-            "cancelled": cancelled,
-            "inProgress": total - completed - failed - cancelled,
-            "successRate": (
-                completed / (completed + failed) if completed + failed else None
-            ),
-        },
-        "cache": {
-            "hit": cache_hit,
-            "miss": cache_miss,
-            "unknown": integer(attempt, "cache_unknown"),
-            "hitRate": (
-                cache_hit / (cache_hit + cache_miss) if cache_hit + cache_miss else None
-            ),
-            "tokenRate": (
-                integer(attempt, "paired_cached_tokens") / paired_input
-                if paired_input > 0
-                else None
-            ),
-            "coverageRate": ((cache_hit + cache_miss) / attempts if attempts else 0),
-        },
-        "tokens": {
-            "input": aggregate_token(attempt, "input_tokens", attempts),
-            "output": aggregate_token(attempt, "output_tokens", attempts),
-            "cachedInput": aggregate_token(
-                attempt,
-                "cached_input_tokens",
-                attempts,
-            ),
-            "reasoning": aggregate_token(
-                attempt,
-                "reasoning_tokens",
-                attempts,
-            ),
-            "total": aggregate_token(attempt, "total_tokens", attempts),
-            "coverageRate": (
-                integer(attempt, "known_total_tokens") / attempts if attempts else 0
-            ),
-        },
-        "byModel": [present_model(row) for row in models],
-        "activity": [present_activity(row) for row in activity],
-    }
-
-
-def present_model(row: dict[str, Any]) -> dict[str, object]:
-    return {
-        "deploymentKey": text(row, "deployment_key"),
-        "model": text(row, "model"),
-        "attempts": integer(row, "attempts"),
-        "inputTokens": optional_integer(row, "input_tokens"),
-        "outputTokens": optional_integer(row, "output_tokens"),
-        "cachedInputTokens": optional_integer(row, "cached_input_tokens"),
-        "reasoningTokens": optional_integer(row, "reasoning_tokens"),
-        "totalTokens": optional_integer(row, "total_tokens"),
-        "unknownUsageCount": integer(row, "unknown_usage_count"),
-    }
-
-
-def present_activity(row: dict[str, Any]) -> dict[str, object]:
-    attempts = integer(row, "attempts")
-    known_attempts = integer(row, "known_token_attempts")
-    return {
-        "date": text(row, "date"),
-        "runs": integer(row, "runs"),
-        "completed": integer(row, "completed"),
-        "failed": integer(row, "failed"),
-        "totalTokens": (
-            optional_integer(row, "total_tokens")
-            if attempts and known_attempts == attempts
-            else None
-        ),
-    }
-
-
-async def fetch_one(
-    connection: DatabaseConnection,
-    query: str,
-    parameters: tuple[object, ...],
-) -> dict[str, Any]:
-    row = await (await connection.execute(query, parameters)).fetchone()
-    if row is None:
-        raise RuntimeError("AI Runtime 报表聚合查询未返回结果")
-    return row
-
-
-async def fetch_all(
-    connection: DatabaseConnection,
-    query: str,
-    parameters: tuple[object, ...],
-) -> list[dict[str, Any]]:
-    return list(await (await connection.execute(query, parameters)).fetchall())
-
-
-def integer(row: dict[str, Any], key: str) -> int:
-    return int(row[key])
-
-
-def optional_integer(row: dict[str, Any], key: str) -> int | None:
-    value = row[key]
-    return int(value) if value is not None else None
-
-
-def aggregate_token(
-    row: dict[str, Any],
-    key: str,
-    attempt_count: int,
-) -> int | None:
-    value = optional_integer(row, key)
-    return value if value is not None else (0 if attempt_count == 0 else None)
-
-
-def text(row: dict[str, Any], key: str) -> str:
-    return str(row[key])
-
-
-def optional_float(row: dict[str, Any], key: str) -> float | None:
-    value = row[key]
-    return float(value) if value is not None else None

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

@@ -1,335 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import time
-import uuid
-
-from .contracts import AgentError, JsonValue
-from .postgres_store_backend import PostgresStoreBackend
-from .sqlite_store import RunStoreCapacityError
-from .store import (
-    CanonicalEvent,
-    IdempotencyConflictError,
-    RunRecord,
-    status_for,
-)
-from .store_cipher import RunStoreCipher
-
-
-class PostgresRunStore:
-    """Multi-replica Run store with encrypted payloads and renewable leases."""
-
-    def __init__(
-        self,
-        database_url: str,
-        cipher: RunStoreCipher,
-        *,
-        max_runs: int = 100_000,
-        max_events_per_run: int = 2_000,
-        max_output_bytes: int = 16 * 1024 * 1024,
-        terminal_ttl_seconds: int = 7 * 24 * 60 * 60,
-        lease_seconds: int = 30,
-    ) -> None:
-        self._cipher = cipher
-        self._max_runs = max_runs
-        self._max_events = max_events_per_run
-        self._max_output_bytes = max_output_bytes
-        self._terminal_ttl = terminal_ttl_seconds
-        self._lease_seconds = lease_seconds
-        self._owner = f"agent_{uuid.uuid4().hex}"
-        self._backend = PostgresStoreBackend(
-            database_url,
-            cipher,
-            self._owner,
-            terminal_ttl_seconds,
-        )
-        self._pool = self._backend.pool
-
-    async def create_or_get(
-        self,
-        record: RunRecord,
-        invocation: JsonValue = None,
-    ) -> tuple[RunRecord, bool]:
-        await self._backend.ready()
-        async with self._pool.connection() as connection:
-            async with connection.transaction():
-                await connection.execute("select pg_advisory_xact_lock(74123001)")
-                await self._backend.prune(connection)
-                current = await self._backend.by_idempotency(
-                    connection,
-                    record.idempotency_key,
-                )
-                if current:
-                    if current.fingerprint != record.fingerprint:
-                        raise IdempotencyConflictError
-                    return current, False
-                count = await connection.execute(
-                    "select count(*) as value from agent_runtime_runs"
-                )
-                row = await count.fetchone()
-                if not row:
-                    raise RuntimeError("Agent Run Store 容量查询失败")
-                if int(row["value"]) >= self._max_runs:
-                    raise RunStoreCapacityError("Agent Run Store 容量已满")
-                release_id = await self._backend.ensure_release(
-                    connection,
-                    record,
-                )
-                now = time.time()
-                inserted = await connection.execute(
-                    """
-                    insert into agent_runtime_runs (
-                      run_id, engine_id, operation_key, idempotency_key, fingerprint,
-                      status, release_id, release_json, trace_id, invocation_cipher,
-                      lease_owner, lease_until,
-                      created_at, updated_at, expires_at
-                    ) values (
-                      %s, %s, %s, %s, %s, 'accepted', %s, %s, %s, %s, %s,
-                      extract(epoch from clock_timestamp()) + %s, %s, %s, %s
-                    )
-                    on conflict (idempotency_key) do nothing
-                    returning run_id
-                    """,
-                    (
-                        record.run_id,
-                        record.engine_id,
-                        record.operation_key,
-                        record.idempotency_key,
-                        record.fingerprint,
-                        release_id,
-                        json.dumps(record.release, ensure_ascii=False),
-                        record.trace_id,
-                        self._cipher.seal(invocation)
-                        if invocation is not None
-                        else None,
-                        self._owner,
-                        self._lease_seconds,
-                        now,
-                        now,
-                        now + self._terminal_ttl,
-                    ),
-                )
-                if await inserted.fetchone() is None:
-                    current = await self._backend.by_idempotency(
-                        connection,
-                        record.idempotency_key,
-                    )
-                    if current is None or current.fingerprint != record.fingerprint:
-                        raise IdempotencyConflictError
-                    return current, False
-                return record, True
-
-    async def get(self, run_id: str) -> RunRecord | None:
-        await self._backend.ready()
-        async with self._pool.connection() as connection:
-            return await self._backend.read(connection, run_id)
-
-    async def get_by_idempotency(self, idempotency_key: str) -> RunRecord | None:
-        await self._backend.ready()
-        async with self._pool.connection() as connection:
-            return await self._backend.by_idempotency(connection, idempotency_key)
-
-    async def append(
-        self,
-        run_id: str,
-        event_type: str,
-        fields: dict[str, object] | None = None,
-    ) -> CanonicalEvent | None:
-        await self._backend.ready()
-        async with self._pool.connection() as connection:
-            async with connection.transaction():
-                record = await self._backend.locked(connection, run_id)
-                if record.terminal:
-                    return None
-                sequence = len(record.events) + 1
-                if sequence >= self._max_events and not event_type.startswith("run."):
-                    event_type = "run.failed"
-                    fields = failure_fields(
-                        sequence,
-                        "Agent 事件超过安全上限",
-                    )
-                event: CanonicalEvent = {
-                    "type": event_type,
-                    "runId": run_id,
-                    "sequence": sequence,
-                    **(fields or {}),
-                }
-                await self._backend.insert_event(
-                    connection,
-                    run_id,
-                    event,
-                    status_for(event_type, record.status),
-                )
-                return event
-
-    async def complete(self, run_id: str, output: JsonValue) -> None:
-        encoded = json.dumps(output, ensure_ascii=False, separators=(",", ":"))
-        await self._backend.ready()
-        async with self._pool.connection() as connection:
-            async with connection.transaction():
-                record = await self._backend.locked(connection, run_id)
-                if record.terminal:
-                    return
-                sequence = len(record.events) + 1
-                if len(encoded.encode()) > self._max_output_bytes:
-                    event: CanonicalEvent = {
-                        "type": "run.failed",
-                        "runId": run_id,
-                        "sequence": sequence,
-                        **failure_fields(sequence, "Agent 输出超过安全上限"),
-                    }
-                    await self._backend.insert_event(
-                        connection,
-                        run_id,
-                        event,
-                        "failed",
-                    )
-                    return
-                event = {
-                    "type": "run.completed",
-                    "runId": run_id,
-                    "sequence": sequence,
-                }
-                await self._backend.insert_event(
-                    connection,
-                    run_id,
-                    event,
-                    "completed",
-                    self._cipher.seal(output),
-                )
-
-    async def events_after(
-        self,
-        run_id: str,
-        after: int,
-        wait_seconds: float,
-    ) -> tuple[list[CanonicalEvent], bool]:
-        deadline = time.monotonic() + wait_seconds
-        while True:
-            record = await self.get(run_id)
-            if record is None:
-                raise KeyError(run_id)
-            events = [event for event in record.events if sequence_of(event) > after]
-            if events or record.terminal or time.monotonic() >= deadline:
-                return events, record.terminal
-            await asyncio.sleep(min(0.5, max(0, deadline - time.monotonic())))
-
-    async def save_invocation(self, run_id: str, value: JsonValue) -> None:
-        await self._backend.update_run(
-            run_id,
-            "invocation_cipher = %s",
-            (self._cipher.seal(value),),
-        )
-
-    async def recoverable(self) -> list[tuple[RunRecord, JsonValue]]:
-        await self._backend.ready()
-        async with self._pool.connection() as connection:
-            async with connection.transaction():
-                cursor = await connection.execute(
-                    """
-                    select run_id from agent_runtime_runs
-                    where status not in ('completed', 'failed', 'cancelled')
-                      and invocation_cipher is not null
-                      and (
-                        lease_until < extract(epoch from clock_timestamp())
-                        or lease_owner = %s
-                      )
-                    order by created_at for update skip locked limit 20
-                    """,
-                    (self._owner,),
-                )
-                rows = await cursor.fetchall()
-                result: list[tuple[RunRecord, JsonValue]] = []
-                for row in rows:
-                    run_id = str(row["run_id"])
-                    await connection.execute(
-                        """
-                        update agent_runtime_runs
-                        set lease_owner = %s,
-                          lease_until = extract(epoch from clock_timestamp()) + %s
-                        where run_id = %s
-                        """,
-                        (self._owner, self._lease_seconds, run_id),
-                    )
-                    record = await self._backend.read(connection, run_id)
-                    cipher = await connection.execute(
-                        """
-                        select invocation_cipher from agent_runtime_runs
-                        where run_id = %s
-                        """,
-                        (run_id,),
-                    )
-                    value = await cipher.fetchone()
-                    if record and value:
-                        result.append(
-                            (
-                                record,
-                                self._cipher.open(str(value["invocation_cipher"])),
-                            )
-                        )
-                return result
-
-    async def clear_invocation(self, run_id: str) -> None:
-        await self._backend.update_run(
-            run_id,
-            "invocation_cipher = null",
-            (),
-        )
-
-    async def renew_lease(self, run_id: str) -> None:
-        await self._backend.update_run(
-            run_id,
-            "lease_until = extract(epoch from clock_timestamp()) + %s",
-            (self._lease_seconds,),
-            owner_required=True,
-            active_required=True,
-        )
-
-    async def release_lease(self, run_id: str) -> None:
-        await self._backend.update_run(
-            run_id,
-            "lease_owner = null, lease_until = 0",
-            (),
-            owner_required=True,
-        )
-
-    async def record_evaluation(
-        self,
-        release_id: str,
-        evaluation_set_key: str,
-        evaluation_set_version: str,
-        metrics: dict[str, float],
-    ) -> str:
-        return await self._backend.record_evaluation(
-            release_id,
-            evaluation_set_key,
-            evaluation_set_version,
-            metrics,
-        )
-
-    async def close(self) -> None:
-        await self._backend.close()
-
-    async def probe(self) -> None:
-        await self._backend.ready()
-        async with self._pool.connection() as connection:
-            await connection.execute("select 1")
-
-
-def sequence_of(event: CanonicalEvent) -> int:
-    value = event.get("sequence")
-    if not isinstance(value, int):
-        raise RuntimeError("Agent Event sequence 无效")
-    return value
-
-
-def failure_fields(sequence: int, message: str) -> dict[str, object]:
-    return {
-        "error": AgentError(
-            code="BUDGET_EXCEEDED",
-            message=message,
-            request_id=f"request_store_{sequence}",
-            retryable=False,
-        ).model_dump(by_alias=True)
-    }