create-windy 0.8.3 → 0.10.0

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

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Awaitable, Callable
-
-from .run_capacity import RunCapacityReservation
-from .store import RunStore
-
-
-async def renew_lease(store: RunStore, run_id: str) -> None:
-    while True:
-        await asyncio.sleep(10)
-        await store.renew_lease(run_id)
-
-
-def complete_task(
-    tasks: set[asyncio.Task[None]],
-    active_run_ids: set[str],
-    run_id: str,
-    task: asyncio.Task[None],
-) -> None:
-    tasks.discard(task)
-    active_run_ids.discard(run_id)
-
-
-async def run_admitted(
-    reservation: RunCapacityReservation,
-    execute: Callable[[], Awaitable[None]],
-) -> None:
-    try:
-        await reservation.enter()
-        await execute()
-    finally:
-        await reservation.release()

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

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-import uuid
-
-from .contracts import AgentError
-from .engine import (
-    ApprovalRequired,
-    ApprovalResolved,
-    OutputDelta,
-    SafeEngineError,
-    ToolCompleted,
-    ToolRequested,
-    UsageReported,
-)
-
-
-def canonical_signal_event(signal: object) -> tuple[str, dict[str, object]]:
-    if isinstance(signal, OutputDelta):
-        return "output.delta", {"text": signal.text}
-    if isinstance(signal, ToolRequested):
-        return "tool.requested", {
-            "toolCallId": signal.tool_call_id,
-            "toolKey": signal.tool_key,
-        }
-    if isinstance(signal, ApprovalRequired):
-        return "approval.required", {
-            "workItemId": signal.work_item_id,
-            "toolCallId": signal.tool_call_id,
-        }
-    if isinstance(signal, ApprovalResolved):
-        return "approval.resolved", {
-            "workItemId": signal.work_item_id,
-            "toolCallId": signal.tool_call_id,
-            "outcome": signal.outcome,
-        }
-    if isinstance(signal, ToolCompleted):
-        return "tool.completed", {"toolCallId": signal.tool_call_id}
-    if isinstance(signal, UsageReported):
-        return "usage.reported", {
-            "attemptSequence": signal.attempt_sequence,
-            "usage": signal.usage.event_value(),
-        }
-    raise TypeError("unsupported engine signal")
-
-
-def canonical_failure_fields(failure: SafeEngineError) -> dict[str, object]:
-    error = AgentError(
-        code=failure.code,
-        message=failure.safe_message,
-        request_id=f"request_{uuid.uuid4().hex}",
-        retryable=failure.retryable,
-    )
-    return {"error": error.model_dump(by_alias=True)}

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

@@ -1,118 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import sqlite3
-import time
-import uuid
-
-from .contracts import JsonValue
-from .sqlite_serialization import encode
-from .store import IdempotencyConflictError, ReleaseNotFoundError, RunRecord
-from .store_cipher import RunStoreCipher
-
-
-class SqliteCatalogMixin:
-    _database: sqlite3.Connection
-    _condition: asyncio.Condition
-    _cipher: RunStoreCipher
-
-    async def get_by_idempotency(self, idempotency_key: str) -> RunRecord | None:
-        async with self._condition:
-            row = self._database.execute(
-                "select run_id from agent_runs where idempotency_key = ?",
-                (idempotency_key,),
-            ).fetchone()
-            return self._read(str(row["run_id"])) if row else None
-
-    async def save_invocation(self, run_id: str, value: JsonValue) -> None:
-        async with self._condition:
-            updated = self._database.execute(
-                """
-                update agent_runs set invocation_cipher = ?, updated_at = ?
-                where run_id = ? and status not in ('completed', 'failed', 'cancelled')
-                """,
-                (self._cipher.seal(value), time.time(), run_id),
-            )
-            if updated.rowcount != 1:
-                raise KeyError(run_id)
-            self._database.commit()
-
-    async def record_evaluation(
-        self,
-        release_id: str,
-        evaluation_set_key: str,
-        evaluation_set_version: str,
-        metrics: dict[str, float],
-    ) -> str:
-        async with self._condition:
-            release = self._database.execute(
-                "select release_id from agent_releases where release_id = ?",
-                (release_id,),
-            ).fetchone()
-            if not release:
-                raise ReleaseNotFoundError
-            existing = self._database.execute(
-                """
-                select evaluation_id, metrics_json
-                from agent_evaluation_results
-                where release_id = ? and evaluation_set_key = ?
-                  and evaluation_set_version = ?
-                """,
-                (release_id, evaluation_set_key, evaluation_set_version),
-            ).fetchone()
-            encoded = encode(metrics)
-            if existing:
-                if str(existing["metrics_json"]) != encoded:
-                    raise IdempotencyConflictError
-                return str(existing["evaluation_id"])
-            evaluation_id = f"eval_{uuid.uuid4().hex}"
-            try:
-                self._database.execute(
-                    """
-                    insert into agent_evaluation_results values (?, ?, ?, ?, ?, ?)
-                    """,
-                    (
-                        evaluation_id,
-                        release_id,
-                        evaluation_set_key,
-                        evaluation_set_version,
-                        encoded,
-                        time.time(),
-                    ),
-                )
-                self._database.commit()
-            except sqlite3.IntegrityError:
-                self._database.rollback()
-                raise IdempotencyConflictError from None
-            return evaluation_id
-
-    def _ensure_release(self, record: RunRecord) -> None:
-        if not isinstance(record.release, dict):
-            raise IdempotencyConflictError
-        release_id = record.release.get("releaseId")
-        if not isinstance(release_id, str):
-            raise IdempotencyConflictError
-        encoded = encode(record.release)
-        existing = self._database.execute(
-            """
-            select operation_key, snapshot_json from agent_releases
-            where release_id = ?
-            """,
-            (release_id,),
-        ).fetchone()
-        if existing and (
-            str(existing["operation_key"]) != record.operation_key
-            or str(existing["snapshot_json"]) != encoded
-        ):
-            raise IdempotencyConflictError
-        self._database.execute(
-            """
-            insert or ignore into agent_releases (
-              release_id, operation_key, snapshot_json, created_at
-            ) values (?, ?, ?, ?)
-            """,
-            (release_id, record.operation_key, encoded, time.time()),
-        )
-
-    def _read(self, run_id: str) -> RunRecord | None:
-        raise NotImplementedError

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

@@ -1,2 +0,0 @@
-class RunStoreCapacityError(Exception):
-    """Raised when the bounded local run store cannot accept more data."""

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

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import sqlite3
-
-from .engine_identity import DIRECT_ENGINE_ID, HISTORICAL_ADK_ENGINE_ID
-
-
-def initialize_database(database: sqlite3.Connection) -> None:
-    database.execute("pragma foreign_keys = on")
-    database.executescript(
-        f"""
-        create table if not exists agent_runs (
-          run_id text primary key,
-          engine_id text not null default '{DIRECT_ENGINE_ID}',
-          operation_key text not null,
-          input_json text not null,
-          idempotency_key text not null unique,
-          fingerprint text not null,
-          status text not null,
-          output_json text not null,
-          created_at real not null,
-          updated_at real not null,
-          invocation_cipher text,
-          release_json text not null default 'null',
-          trace_id text not null default ''
-        );
-        create table if not exists agent_events (
-          run_id text not null references agent_runs(run_id) on delete cascade,
-          sequence integer not null,
-          event_json text not null,
-          primary key (run_id, sequence)
-        );
-        """
-    )
-    columns = {
-        str(row["name"]) for row in database.execute("pragma table_info(agent_runs)")
-    }
-    if "invocation_cipher" not in columns:
-        database.execute("alter table agent_runs add column invocation_cipher text")
-    if "release_json" not in columns:
-        database.execute(
-            "alter table agent_runs add column release_json "
-            "text not null default 'null'"
-        )
-    if "trace_id" not in columns:
-        database.execute(
-            "alter table agent_runs add column trace_id text not null default ''"
-        )
-    if "engine_id" not in columns:
-        database.execute(
-            "alter table agent_runs add column engine_id "
-            f"text not null default '{HISTORICAL_ADK_ENGINE_ID}'"
-        )
-    database.executescript(
-        """
-        create table if not exists agent_releases (
-          release_id text primary key,
-          operation_key text not null,
-          snapshot_json text not null,
-          created_at real not null
-        );
-        create table if not exists agent_evaluation_results (
-          evaluation_id text primary key,
-          release_id text not null references agent_releases(release_id),
-          evaluation_set_key text not null,
-          evaluation_set_version text not null,
-          metrics_json text not null,
-          created_at real not null,
-          unique(release_id, evaluation_set_key, evaluation_set_version)
-        );
-        """
-    )
-    database.commit()

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

@@ -1,16 +0,0 @@
-from __future__ import annotations
-
-import json
-
-from .store import CanonicalEvent
-
-
-def encode(value: object) -> str:
-    return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
-
-
-def sequence_of(event: CanonicalEvent) -> int:
-    value = event.get("sequence")
-    if not isinstance(value, int):
-        raise RuntimeError("Agent Event sequence 无效")
-    return value

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

@@ -1,350 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import sqlite3
-import time
-from pathlib import Path
-from typing import cast
-
-from .contracts import AgentError, AgentErrorCode, JsonValue, RunStatus
-from .sqlite_catalog import SqliteCatalogMixin
-from .sqlite_errors import RunStoreCapacityError as RunStoreCapacityError
-from .sqlite_schema import initialize_database
-from .sqlite_serialization import encode, sequence_of
-from .store import (
-    CanonicalEvent,
-    IdempotencyConflictError,
-    RunRecord,
-    status_for,
-)
-from .store_cipher import RunStoreCipher
-
-__all__ = ["RunStoreCapacityError", "SqliteRunStore"]
-
-
-class SqliteRunStore(SqliteCatalogMixin):
-    """Single-replica durable Run store with bounded rows, events and output."""
-
-    def __init__(
-        self,
-        path: str,
-        cipher: RunStoreCipher,
-        *,
-        max_runs: int = 10_000,
-        max_events_per_run: int = 2_000,
-        max_output_bytes: int = 16 * 1024 * 1024,
-        terminal_ttl_seconds: int = 7 * 24 * 60 * 60,
-    ) -> None:
-        Path(path).parent.mkdir(parents=True, exist_ok=True)
-        self._database = sqlite3.connect(path, check_same_thread=False)
-        self._database.row_factory = sqlite3.Row
-        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._condition = asyncio.Condition()
-        self._cipher = cipher
-        initialize_database(self._database)
-        self._recover_incomplete()
-
-    async def create_or_get(
-        self,
-        record: RunRecord,
-        invocation: JsonValue = None,
-    ) -> tuple[RunRecord, bool]:
-        async with self._condition:
-            existing = self._database.execute(
-                "select run_id from agent_runs where idempotency_key = ?",
-                (record.idempotency_key,),
-            ).fetchone()
-            if existing:
-                current = self._read(str(existing["run_id"]))
-                if current is None or current.fingerprint != record.fingerprint:
-                    raise IdempotencyConflictError
-                return current, False
-            self._prune()
-            count = int(
-                self._database.execute("select count(*) from agent_runs").fetchone()[0]
-            )
-            if count >= self._max_runs:
-                raise RunStoreCapacityError("Agent Run Store 容量已满")
-            now = time.time()
-            try:
-                self._database.execute(
-                    """
-                    insert into agent_runs (
-                      run_id, engine_id, operation_key, input_json, idempotency_key,
-                      fingerprint, status, output_json, created_at, updated_at,
-                      release_json, trace_id, invocation_cipher
-                    ) values (?, ?, ?, ?, ?, ?, 'accepted', 'null', ?, ?, ?, ?, ?)
-                    """,
-                    (
-                        record.run_id,
-                        record.engine_id,
-                        record.operation_key,
-                        "null",
-                        record.idempotency_key,
-                        record.fingerprint,
-                        now,
-                        now,
-                        encode(record.release),
-                        record.trace_id,
-                        self._cipher.seal(invocation)
-                        if invocation is not None
-                        else None,
-                    ),
-                )
-                self._ensure_release(record)
-                self._database.commit()
-            except Exception:
-                self._database.rollback()
-                raise
-            self._condition.notify_all()
-            return record, True
-
-    async def get(self, run_id: str) -> RunRecord | None:
-        async with self._condition:
-            return self._read(run_id)
-
-    async def append(
-        self,
-        run_id: str,
-        event_type: str,
-        fields: dict[str, object] | None = None,
-    ) -> CanonicalEvent | None:
-        async with self._condition:
-            record = self._read(run_id)
-            if record is None:
-                raise KeyError(run_id)
-            if record.terminal:
-                return None
-            sequence = len(record.events) + 1
-            if sequence >= self._max_events and not event_type.startswith("run."):
-                self._append_failure(run_id, sequence, "Agent 事件超过安全上限")
-                self._condition.notify_all()
-                raise RunStoreCapacityError("Agent 事件超过安全上限")
-            event: CanonicalEvent = {
-                "type": event_type,
-                "runId": run_id,
-                "sequence": sequence,
-                **(fields or {}),
-            }
-            self._insert_event(run_id, event, status_for(event_type, record.status))
-            self._condition.notify_all()
-            return event
-
-    async def complete(self, run_id: str, output: JsonValue) -> None:
-        async with self._condition:
-            record = self._read(run_id)
-            if record is None:
-                raise KeyError(run_id)
-            if record.terminal:
-                return
-            encoded = encode(output)
-            sequence = len(record.events) + 1
-            if len(encoded.encode()) > self._max_output_bytes:
-                self._append_failure(run_id, sequence, "Agent 输出超过安全上限")
-                self._condition.notify_all()
-                return
-            event: CanonicalEvent = {
-                "type": "run.completed",
-                "runId": run_id,
-                "sequence": sequence,
-            }
-            self._insert_event(run_id, event, "completed", encoded)
-            self._condition.notify_all()
-
-    async def events_after(
-        self,
-        run_id: str,
-        after: int,
-        wait_seconds: float,
-    ) -> tuple[list[CanonicalEvent], bool]:
-        async with self._condition:
-
-            def ready() -> bool:
-                record = self._read(run_id)
-                return bool(
-                    record
-                    and (
-                        any(sequence_of(event) > after for event in record.events)
-                        or record.terminal
-                    )
-                )
-
-            if not ready():
-                try:
-                    await asyncio.wait_for(
-                        self._condition.wait_for(ready),
-                        wait_seconds,
-                    )
-                except TimeoutError:
-                    return [], False
-            record = self._read(run_id)
-            if record is None:
-                raise KeyError(run_id)
-            return (
-                [event for event in record.events if sequence_of(event) > after],
-                record.terminal,
-            )
-
-    async def recoverable(self) -> list[tuple[RunRecord, JsonValue]]:
-        async with self._condition:
-            rows = self._database.execute(
-                """
-                select run_id, invocation_cipher from agent_runs
-                where status not in ('completed', 'failed', 'cancelled')
-                  and invocation_cipher is not null
-                order by created_at
-                """
-            ).fetchall()
-            result: list[tuple[RunRecord, JsonValue]] = []
-            for row in rows:
-                record = self._read(str(row["run_id"]))
-                if record is not None:
-                    result.append(
-                        (
-                            record,
-                            self._cipher.open(str(row["invocation_cipher"])),
-                        )
-                    )
-            return result
-
-    async def clear_invocation(self, run_id: str) -> None:
-        async with self._condition:
-            self._database.execute(
-                "update agent_runs set invocation_cipher = null where run_id = ?",
-                (run_id,),
-            )
-            self._database.commit()
-
-    async def renew_lease(self, run_id: str) -> None:
-        record = await self.get(run_id)
-        if record is None or record.terminal:
-            raise KeyError(run_id)
-
-    async def release_lease(self, run_id: str) -> None:
-        if await self.get(run_id) is None:
-            raise KeyError(run_id)
-
-    async def probe(self) -> None:
-        async with self._condition:
-            self._database.execute("select 1").fetchone()
-
-    async def close(self) -> None:
-        self._database.close()
-
-    def _recover_incomplete(self) -> None:
-        rows = self._database.execute(
-            """
-            select run_id from agent_runs
-            where status not in ('completed', 'failed', 'cancelled')
-              and invocation_cipher is null
-            """
-        ).fetchall()
-        for row in rows:
-            run_id = str(row["run_id"])
-            sequence = (
-                int(
-                    self._database.execute(
-                        "select count(*) from agent_events where run_id = ?",
-                        (run_id,),
-                    ).fetchone()[0]
-                )
-                + 1
-            )
-            self._append_failure(
-                run_id,
-                sequence,
-                "Agent Runtime 重启中断了 Run",
-                code="RUNTIME_UNAVAILABLE",
-                retryable=True,
-            )
-        self._database.commit()
-
-    def _read(self, run_id: str) -> RunRecord | None:
-        row = self._database.execute(
-            "select * from agent_runs where run_id = ?",
-            (run_id,),
-        ).fetchone()
-        if not row:
-            return None
-        events = [
-            json.loads(str(event["event_json"]))
-            for event in self._database.execute(
-                """
-                select event_json from agent_events
-                where run_id = ? order by sequence
-                """,
-                (run_id,),
-            )
-        ]
-        return RunRecord(
-            run_id=str(row["run_id"]),
-            engine_id=str(row["engine_id"]),
-            operation_key=str(row["operation_key"]),
-            input=json.loads(str(row["input_json"])),
-            idempotency_key=str(row["idempotency_key"]),
-            fingerprint=str(row["fingerprint"]),
-            status=cast(RunStatus, str(row["status"])),
-            events=events,
-            output=json.loads(str(row["output_json"])),
-            release=json.loads(str(row["release_json"])),
-            trace_id=str(row["trace_id"]),
-        )
-
-    def _insert_event(
-        self,
-        run_id: str,
-        event: CanonicalEvent,
-        status: RunStatus,
-        output_json: str | None = None,
-    ) -> None:
-        self._database.execute(
-            "insert into agent_events values (?, ?, ?)",
-            (run_id, event["sequence"], encode(event)),
-        )
-        self._database.execute(
-            """
-            update agent_runs
-            set status = ?, output_json = coalesce(?, output_json), updated_at = ?
-            where run_id = ?
-            """,
-            (status, output_json, time.time(), run_id),
-        )
-        self._database.commit()
-
-    def _append_failure(
-        self,
-        run_id: str,
-        sequence: int,
-        message: str,
-        *,
-        code: AgentErrorCode = "BUDGET_EXCEEDED",
-        retryable: bool = False,
-    ) -> None:
-        event: CanonicalEvent = {
-            "type": "run.failed",
-            "runId": run_id,
-            "sequence": sequence,
-            "error": AgentError(
-                code=code,
-                message=message,
-                request_id=f"request_store_{sequence}",
-                retryable=retryable,
-            ).model_dump(by_alias=True),
-        }
-        self._insert_event(run_id, event, "failed")
-
-    def _prune(self) -> None:
-        cutoff = time.time() - self._terminal_ttl
-        self._database.execute(
-            """
-            delete from agent_runs
-            where status in ('completed', 'failed', 'cancelled')
-              and updated_at < ?
-            """,
-            (cutoff,),
-        )
-        self._database.commit()

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

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-import json
-from collections.abc import AsyncIterator
-
-from .service import AgentRunService
-
-
-def encode_event(event: dict[str, object]) -> str:
-    sequence = event["sequence"]
-    event_type = event["type"]
-    data = json.dumps(event, ensure_ascii=False, separators=(",", ":"))
-    return f"id: {sequence}\nevent: {event_type}\ndata: {data}\n\n"
-
-
-async def event_stream(
-    service: AgentRunService,
-    run_id: str,
-    after: int,
-    heartbeat_seconds: float,
-) -> AsyncIterator[str]:
-    cursor = after
-    while True:
-        events, terminal = await service.store.events_after(
-            run_id,
-            cursor,
-            heartbeat_seconds,
-        )
-        if not events:
-            if terminal:
-                return
-            yield ": heartbeat\n\n"
-            continue
-        for event in events:
-            sequence = event["sequence"]
-            if not isinstance(sequence, int):
-                raise RuntimeError("invalid stored sequence")
-            cursor = sequence
-            yield encode_event(event)
-        if terminal:
-            return