create-windy 0.8.3 → 0.10.0

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

@@ -1,333 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import time
-import uuid
-from typing import Any, cast
-
-from psycopg import AsyncConnection
-from psycopg.rows import dict_row
-from psycopg_pool import AsyncConnectionPool
-
-from .contracts import JsonValue, RunStatus
-from .store import (
-    CanonicalEvent,
-    IdempotencyConflictError,
-    ReleaseNotFoundError,
-    RunRecord,
-)
-from .store_cipher import RunStoreCipher
-
-type DatabaseConnection = AsyncConnection[dict[str, Any]]
-
-
-class PostgresStoreBackend:
-    def __init__(
-        self,
-        database_url: str,
-        cipher: RunStoreCipher,
-        owner: str,
-        terminal_ttl_seconds: int,
-    ) -> None:
-        self.pool = cast(
-            AsyncConnectionPool[DatabaseConnection],
-            AsyncConnectionPool(
-                database_url,
-                min_size=1,
-                max_size=10,
-                open=False,
-                kwargs={"row_factory": dict_row},
-            ),
-        )
-        self.cipher = cipher
-        self.owner = owner
-        self.terminal_ttl = terminal_ttl_seconds
-        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 close(self) -> None:
-        if self._opened:
-            await self.pool.close()
-
-    async def read(
-        self,
-        connection: DatabaseConnection,
-        run_id: str,
-    ) -> RunRecord | None:
-        cursor = await connection.execute(
-            "select * from agent_runtime_runs where run_id = %s",
-            (run_id,),
-        )
-        row = await cursor.fetchone()
-        if not row:
-            return None
-        events_cursor = await connection.execute(
-            """
-            select event_cipher from agent_runtime_events
-            where run_id = %s order by sequence
-            """,
-            (run_id,),
-        )
-        events = [
-            cast(CanonicalEvent, self.cipher.open(str(item["event_cipher"])))
-            for item in await events_cursor.fetchall()
-        ]
-        output = (
-            self.cipher.open(str(row["output_cipher"]))
-            if row["output_cipher"]
-            else None
-        )
-        return RunRecord(
-            run_id=str(row["run_id"]),
-            engine_id=str(row["engine_id"]),
-            operation_key=str(row["operation_key"]),
-            input=None,
-            idempotency_key=str(row["idempotency_key"]),
-            fingerprint=str(row["fingerprint"]),
-            release=cast(JsonValue, row["release_json"]),
-            trace_id=str(row["trace_id"]),
-            status=cast(RunStatus, str(row["status"])),
-            events=events,
-            output=output,
-        )
-
-    async def locked(
-        self,
-        connection: DatabaseConnection,
-        run_id: str,
-    ) -> RunRecord:
-        await connection.execute(
-            "select run_id from agent_runtime_runs where run_id = %s for update",
-            (run_id,),
-        )
-        record = await self.read(connection, run_id)
-        if record is None:
-            raise KeyError(run_id)
-        return record
-
-    async def insert_event(
-        self,
-        connection: DatabaseConnection,
-        run_id: str,
-        event: CanonicalEvent,
-        status: RunStatus,
-        output_cipher: str | None = None,
-    ) -> None:
-        await connection.execute(
-            """
-            insert into agent_runtime_events (run_id, sequence, event_cipher)
-            values (%s, %s, %s)
-            """,
-            (
-                run_id,
-                event["sequence"],
-                self.cipher.seal(cast(JsonValue, event)),
-            ),
-        )
-        now = time.time()
-        await connection.execute(
-            """
-            update agent_runtime_runs
-            set status = %s, output_cipher = coalesce(%s, output_cipher),
-              updated_at = %s, expires_at = %s
-            where run_id = %s
-            """,
-            (
-                status,
-                output_cipher,
-                now,
-                now + self.terminal_ttl,
-                run_id,
-            ),
-        )
-
-    async def update_run(
-        self,
-        run_id: str,
-        assignment: str,
-        values: tuple[object, ...],
-        *,
-        owner_required: bool = False,
-        active_required: bool = False,
-    ) -> None:
-        await self.ready()
-        owner_clause = " and lease_owner = %s" if owner_required else ""
-        active_clause = (
-            " and status not in ('completed', 'failed', 'cancelled')"
-            if active_required
-            else ""
-        )
-        parameters = (
-            *values,
-            run_id,
-            *((self.owner,) if owner_required else ()),
-        )
-        async with self.pool.connection() as connection:
-            cursor = await connection.execute(
-                f"update agent_runtime_runs set {assignment} "
-                f"where run_id = %s{owner_clause}{active_clause}",
-                parameters,
-            )
-            if cursor.rowcount != 1:
-                raise KeyError(run_id)
-
-    async def by_idempotency(
-        self,
-        connection: DatabaseConnection,
-        idempotency_key: str,
-    ) -> RunRecord | None:
-        cursor = await connection.execute(
-            """
-            select run_id from agent_runtime_runs
-            where idempotency_key = %s
-            """,
-            (idempotency_key,),
-        )
-        row = await cursor.fetchone()
-        return await self.read(connection, str(row["run_id"])) if row else None
-
-    async def ensure_release(
-        self,
-        connection: DatabaseConnection,
-        record: RunRecord,
-    ) -> str:
-        if not isinstance(record.release, dict):
-            raise IdempotencyConflictError
-        release_id = record.release.get("releaseId")
-        if not isinstance(release_id, str):
-            raise IdempotencyConflictError
-        encoded = json.dumps(
-            record.release,
-            sort_keys=True,
-            separators=(",", ":"),
-        )
-        await connection.execute(
-            """
-            insert into agent_operation_releases (
-              release_id, operation_key, snapshot_json, created_at
-            ) values (%s, %s, %s::jsonb, %s)
-            on conflict (release_id) do nothing
-            """,
-            (release_id, record.operation_key, encoded, time.time()),
-        )
-        cursor = await connection.execute(
-            """
-            select operation_key, snapshot_json from agent_operation_releases
-            where release_id = %s
-            """,
-            (release_id,),
-        )
-        existing = await cursor.fetchone()
-        if not existing:
-            raise IdempotencyConflictError
-        actual = json.dumps(
-            existing["snapshot_json"],
-            sort_keys=True,
-            separators=(",", ":"),
-        )
-        if str(existing["operation_key"]) != record.operation_key or actual != encoded:
-            raise IdempotencyConflictError
-        return release_id
-
-    async def prune(self, connection: DatabaseConnection) -> None:
-        await connection.execute(
-            """
-            delete from agent_runtime_runs
-            where status in ('completed', 'failed', 'cancelled')
-              and expires_at < %s
-            """,
-            (time.time(),),
-        )
-
-    async def record_evaluation(
-        self,
-        release_id: str,
-        evaluation_set_key: str,
-        evaluation_set_version: str,
-        metrics: dict[str, float],
-    ) -> str:
-        await self.ready()
-        encoded = json.dumps(metrics, sort_keys=True, separators=(",", ":"))
-        async with self.pool.connection() as connection:
-            async with connection.transaction():
-                release = await connection.execute(
-                    """
-                    select release_id from agent_operation_releases
-                    where release_id = %s
-                    """,
-                    (release_id,),
-                )
-                if await release.fetchone() is None:
-                    raise ReleaseNotFoundError
-                cursor = await connection.execute(
-                    """
-                    select evaluation_id, metrics_json
-                    from agent_evaluation_results
-                    where release_id = %s and evaluation_set_key = %s
-                      and evaluation_set_version = %s
-                    """,
-                    (release_id, evaluation_set_key, evaluation_set_version),
-                )
-                existing = await cursor.fetchone()
-                if existing:
-                    actual = json.dumps(
-                        existing["metrics_json"],
-                        sort_keys=True,
-                        separators=(",", ":"),
-                    )
-                    if actual != encoded:
-                        raise IdempotencyConflictError
-                    return str(existing["evaluation_id"])
-                evaluation_id = f"eval_{uuid.uuid4().hex}"
-                inserted = await connection.execute(
-                    """
-                    insert into agent_evaluation_results (
-                      evaluation_id, release_id, evaluation_set_key,
-                      evaluation_set_version, metrics_json, created_at
-                    ) values (%s, %s, %s, %s, %s::jsonb, %s)
-                    on conflict (
-                      release_id, evaluation_set_key, evaluation_set_version
-                    ) do nothing
-                    returning evaluation_id
-                    """,
-                    (
-                        evaluation_id,
-                        release_id,
-                        evaluation_set_key,
-                        evaluation_set_version,
-                        encoded,
-                        time.time(),
-                    ),
-                )
-                row = await inserted.fetchone()
-                if row:
-                    return str(row["evaluation_id"])
-                repeated = await connection.execute(
-                    """
-                    select evaluation_id, metrics_json
-                    from agent_evaluation_results
-                    where release_id = %s and evaluation_set_key = %s
-                      and evaluation_set_version = %s
-                    """,
-                    (release_id, evaluation_set_key, evaluation_set_version),
-                )
-                raced = await repeated.fetchone()
-                if not raced:
-                    raise IdempotencyConflictError
-                actual = json.dumps(
-                    raced["metrics_json"],
-                    sort_keys=True,
-                    separators=(",", ":"),
-                )
-                if actual != encoded:
-                    raise IdempotencyConflictError
-                return str(raced["evaluation_id"])

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

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-import sqlite3
-import threading
-import time
-import uuid
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass(frozen=True)
-class ProviderAttemptAudit:
-    deployment_key: str
-    operation_key: str
-    run_id: str
-    attempt: int
-    classifications: tuple[str, ...]
-    sent_bytes: int
-    decision: str
-
-
-class ProviderAuditStore:
-    """Append-only Provider attempt metadata, except explicit TTL expiry."""
-
-    def __init__(self, path: str, *, retention_days: int) -> None:
-        if not path.strip():
-            raise ValueError("Provider 发送审计 Store 路径不能为空")
-        if not 1 <= retention_days <= 3650:
-            raise ValueError("Provider 发送审计留存天数超出范围")
-        Path(path).parent.mkdir(parents=True, exist_ok=True)
-        self._database = sqlite3.connect(path, check_same_thread=False)
-        self._lock = threading.RLock()
-        self._retention_seconds = retention_days * 24 * 60 * 60
-        self.retention_days = retention_days
-        self._initialize()
-        self.purge_expired()
-
-    def append(self, audit: ProviderAttemptAudit) -> None:
-        with self._lock:
-            self.purge_expired()
-            try:
-                self._database.execute(
-                    """
-                    insert into provider_attempt_audit (
-                      event_id, deployment_key, operation_key, run_id, attempt,
-                      classifications, sent_bytes, decision, occurred_at
-                    ) values (?, ?, ?, ?, ?, ?, ?, ?, ?)
-                    """,
-                    (
-                        f"pa_{uuid.uuid4().hex}",
-                        audit.deployment_key,
-                        audit.operation_key,
-                        audit.run_id,
-                        audit.attempt,
-                        ",".join(audit.classifications),
-                        audit.sent_bytes,
-                        audit.decision,
-                        time.time(),
-                    ),
-                )
-                self._database.commit()
-            except Exception:
-                self._database.rollback()
-                raise
-
-    def purge_expired(self, *, now: float | None = None) -> int:
-        with self._lock:
-            cutoff = (now or time.time()) - self._retention_seconds
-            cursor = self._database.execute(
-                "delete from provider_attempt_audit where occurred_at < ?",
-                (cutoff,),
-            )
-            deleted = max(cursor.rowcount, 0)
-            self._database.execute(
-                """
-                update provider_audit_retention
-                set last_purge_at = ?, last_deleted = ?,
-                  total_deleted = total_deleted + ?
-                where singleton = 1
-                """,
-                (now or time.time(), deleted, deleted),
-            )
-            self._database.commit()
-            return deleted
-
-    def health(self) -> dict[str, int | float | str | None]:
-        with self._lock:
-            return self._health()
-
-    def _health(self) -> dict[str, int | float | str | None]:
-        row = self._database.execute(
-            """
-            select count(*) as retained,
-              sum(case when decision = 'reject' then 1 else 0 end) as rejected,
-              sum(case when decision = 'redact' then 1 else 0 end) as redacted,
-              max(occurred_at) as last_attempt_at
-            from provider_attempt_audit
-            """
-        ).fetchone()
-        retention = self._database.execute(
-            "select * from provider_audit_retention where singleton = 1"
-        ).fetchone()
-        return {
-            "status": "healthy",
-            "retentionDays": self.retention_days,
-            "retainedRecords": int(row[0] or 0),
-            "rejectedAttempts": int(row[1] or 0),
-            "redactedAttempts": int(row[2] or 0),
-            "lastAttemptAt": row[3],
-            "lastPurgeAt": retention[1],
-            "lastDeletedRecords": int(retention[2]),
-            "totalDeletedRecords": int(retention[3]),
-        }
-
-    def close(self) -> None:
-        with self._lock:
-            self._database.close()
-
-    def _initialize(self) -> None:
-        self._database.executescript(
-            """
-            create table if not exists provider_attempt_audit (
-              event_id text primary key,
-              deployment_key text not null,
-              operation_key text not null,
-              run_id text not null,
-              attempt integer not null,
-              classifications text not null,
-              sent_bytes integer not null,
-              decision text not null check(decision in ('allow', 'redact', 'reject')),
-              occurred_at real not null,
-              unique(run_id, attempt)
-            );
-            create table if not exists provider_audit_retention (
-              singleton integer primary key check(singleton = 1),
-              last_purge_at real,
-              last_deleted integer not null,
-              total_deleted integer not null
-            );
-            insert or ignore into provider_audit_retention
-              values (1, null, 0, 0);
-            """
-        )
-        self._database.commit()