create-windy 0.8.2 → 0.9.1

package/template/apps/agent-server/tests/test_postgres_report_summary.py

@@ -1,298 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, cast
-
-from southwind_agent_server.postgres_report_summary import (
-    present_summary,
-    summary,
-)
-from southwind_agent_server.report_types import ReportFilter
-
-
-async def test_summary_uses_bounded_sql_aggregates_and_projects_result() -> None:
-    connection = FakeConnection()
-    result = await summary(
-        cast(Any, FakePool(connection)),
-        ReportFilter(
-            0,
-            500,
-            selected_actor_id="actor_visible",
-            scope_restricted=True,
-            actor_ids=("actor_visible",),
-            department_ids=("department_visible",),
-        ),
-        retention_days=90,
-        generated_at=400,
-    )
-
-    assert len(connection.queries) == 4
-    rendered_sql = "\n".join(query for query, _ in connection.queries)
-    assert "select *" not in rendered_sql.lower()
-    assert "run_id = any" not in rendered_sql.lower()
-    assert "group by a.deployment_key" in rendered_sql
-    assert "group by 1" in rendered_sql
-    assert "at time zone 'UTC'" in rendered_sql
-    unbounded_attempt_rollup = (
-        "from agent_runtime_report_attempts\n              group by run_id"
-    )
-    assert unbounded_attempt_rollup not in rendered_sql
-    assert "with run_activity as" in rendered_sql
-    assert "attempt_activity as" in rendered_sql
-    for index, (query, parameters) in enumerate(connection.queries):
-        assert "r.actor_id = %s" in query
-        assert "r.department_id = any(%s)" in query
-        expected = (
-            0,
-            500,
-            400,
-            "actor_visible",
-            ["actor_visible"],
-            ["department_visible"],
-        )
-        assert parameters == (expected * 2 if index == 3 else expected)
-        if index > 0:
-            assert "a.started_at >= %s" in query
-            assert "a.started_at <= %s" in query
-            assert "a.finished_at is not null" in query
-
-    assert result == {
-        "generatedAt": "1970-01-01T00:06:40Z",
-        "reportingAvailableFrom": "1970-01-01T00:01:40Z",
-        "retentionDays": 90,
-        "runs": {
-            "total": 3,
-            "completed": 1,
-            "failed": 1,
-            "cancelled": 1,
-            "inProgress": 0,
-            "successRate": 0.5,
-        },
-        "cache": {
-            "hit": 1,
-            "miss": 1,
-            "unknown": 1,
-            "hitRate": 0.5,
-            "tokenRate": 0.5,
-            "coverageRate": 2 / 3,
-        },
-        "tokens": {
-            "input": 30,
-            "output": 10,
-            "cachedInput": 5,
-            "reasoning": 2,
-            "total": 40,
-            "coverageRate": 2 / 3,
-        },
-        "byModel": [
-            {
-                "deploymentKey": "ai.openai-compatible",
-                "model": "qwen",
-                "attempts": 3,
-                "inputTokens": 30,
-                "outputTokens": 10,
-                "cachedInputTokens": 5,
-                "reasoningTokens": 2,
-                "totalTokens": 40,
-                "unknownUsageCount": 1,
-            }
-        ],
-        "activity": [
-            {
-                "date": "2026-07-30",
-                "runs": 3,
-                "completed": 1,
-                "failed": 1,
-                "totalTokens": None,
-            },
-            {
-                "date": "2026-07-31",
-                "runs": 0,
-                "completed": 0,
-                "failed": 0,
-                "totalTokens": None,
-            },
-        ],
-    }
-
-
-def test_summary_keeps_completely_unknown_token_facts_null() -> None:
-    result = present_summary(
-        {
-            "total": 1,
-            "completed": 1,
-            "failed": 0,
-            "cancelled": 0,
-            "available_from": 100,
-        },
-        {
-            "attempts": 1,
-            "available_from": 100,
-            "cache_hit": 0,
-            "cache_miss": 0,
-            "cache_unknown": 1,
-            "known_total_tokens": 0,
-            "input_tokens": None,
-            "output_tokens": None,
-            "cached_input_tokens": None,
-            "reasoning_tokens": None,
-            "total_tokens": None,
-            "paired_input_tokens": 0,
-            "paired_cached_tokens": 0,
-        },
-        [
-            {
-                "deployment_key": "ai.openai-compatible",
-                "model": "qwen",
-                "attempts": 1,
-                "input_tokens": None,
-                "output_tokens": None,
-                "cached_input_tokens": None,
-                "reasoning_tokens": None,
-                "total_tokens": None,
-                "unknown_usage_count": 1,
-            }
-        ],
-        [
-            {
-                "date": "2026-07-31",
-                "runs": 1,
-                "completed": 1,
-                "failed": 0,
-                "attempts": 1,
-                "known_token_attempts": 0,
-                "total_tokens": None,
-            }
-        ],
-        90,
-        400,
-    )
-
-    assert result["tokens"] == {
-        "input": None,
-        "output": None,
-        "cachedInput": None,
-        "reasoning": None,
-        "total": None,
-        "coverageRate": 0,
-    }
-    assert result["byModel"][0]["totalTokens"] is None  # type: ignore[index]
-    assert result["activity"][0]["totalTokens"] is None  # type: ignore[index]
-
-
-class FakePool:
-    def __init__(self, connection: FakeConnection) -> None:
-        self.value = connection
-
-    def connection(self) -> FakeLease:
-        return FakeLease(self.value)
-
-
-class FakeLease:
-    def __init__(self, connection: FakeConnection) -> None:
-        self.value = connection
-
-    async def __aenter__(self) -> FakeConnection:
-        return self.value
-
-    async def __aexit__(
-        self,
-        exception_type: object,
-        exception: object,
-        traceback: object,
-    ) -> None:
-        return None
-
-
-class FakeConnection:
-    def __init__(self) -> None:
-        self.queries: list[tuple[str, tuple[object, ...]]] = []
-
-    async def execute(
-        self,
-        query: str,
-        parameters: tuple[object, ...],
-    ) -> FakeCursor:
-        self.queries.append((query, parameters))
-        if "min(r.created_at) as available_from" in query:
-            return FakeCursor(
-                [
-                    {
-                        "total": 3,
-                        "completed": 1,
-                        "failed": 1,
-                        "cancelled": 1,
-                        "available_from": 100,
-                    }
-                ]
-            )
-        if "as paired_input_tokens" in query:
-            return FakeCursor(
-                [
-                    {
-                        "attempts": 3,
-                        "available_from": 200,
-                        "cache_hit": 1,
-                        "cache_miss": 1,
-                        "cache_unknown": 1,
-                        "known_total_tokens": 2,
-                        "input_tokens": 30,
-                        "output_tokens": 10,
-                        "cached_input_tokens": 5,
-                        "reasoning_tokens": 2,
-                        "total_tokens": 40,
-                        "paired_input_tokens": 10,
-                        "paired_cached_tokens": 5,
-                    }
-                ]
-            )
-        if "group by a.deployment_key" in query:
-            return FakeCursor(
-                [
-                    {
-                        "deployment_key": "ai.openai-compatible",
-                        "model": "qwen",
-                        "attempts": 3,
-                        "input_tokens": 30,
-                        "output_tokens": 10,
-                        "cached_input_tokens": 5,
-                        "reasoning_tokens": 2,
-                        "total_tokens": 40,
-                        "unknown_usage_count": 1,
-                    }
-                ]
-            )
-        if "with run_activity as" in query:
-            return FakeCursor(
-                [
-                    {
-                        "date": "2026-07-30",
-                        "runs": 3,
-                        "completed": 1,
-                        "failed": 1,
-                        "attempts": 0,
-                        "known_token_attempts": 0,
-                        "total_tokens": None,
-                    },
-                    {
-                        "date": "2026-07-31",
-                        "runs": 0,
-                        "completed": 0,
-                        "failed": 0,
-                        "attempts": 3,
-                        "known_token_attempts": 2,
-                        "total_tokens": 40,
-                    },
-                ]
-            )
-        raise AssertionError("unexpected SQL")
-
-
-class FakeCursor:
-    def __init__(self, rows: list[dict[str, Any]]) -> None:
-        self.rows = rows
-
-    async def fetchone(self) -> dict[str, Any] | None:
-        return self.rows[0] if self.rows else None
-
-    async def fetchall(self) -> list[dict[str, Any]]:
-        return self.rows

package/template/apps/agent-server/tests/test_postgres_store.py

@@ -1,135 +0,0 @@
-from __future__ import annotations
-
-import os
-import uuid
-from typing import cast
-
-import pytest
-from psycopg import AsyncConnection
-
-from southwind_agent_server.contracts import JsonValue
-from southwind_agent_server.postgres_store import PostgresRunStore
-from southwind_agent_server.store import IdempotencyConflictError, RunRecord
-from southwind_agent_server.store_cipher import RunStoreCipher
-
-DATABASE_URL = os.environ.get("AGENT_TEST_DATABASE_URL", "")
-pytestmark = pytest.mark.skipif(
-    not DATABASE_URL,
-    reason="需要 AGENT_TEST_DATABASE_URL",
-)
-TEST_CIPHER = RunStoreCipher("postgres-test-secret-" * 2)
-
-
-async def test_multi_replica_replay_recovery_and_immutable_release() -> None:
-    suffix = uuid.uuid4().hex
-    first = PostgresRunStore(DATABASE_URL, TEST_CIPHER, lease_seconds=1)
-    second = PostgresRunStore(DATABASE_URL, TEST_CIPHER, lease_seconds=1)
-    record = fixture(suffix)
-    try:
-        created, is_new = await first.create_or_get(
-            record,
-            {"input": {"secret": f"sensitive-{suffix}"}},
-        )
-        repeated, repeated_is_new = await second.create_or_get(record)
-        by_idempotency = await second.get_by_idempotency(record.idempotency_key)
-        await first.append(record.run_id, "run.started")
-        await first.append(record.run_id, "output.delta", {"text": "one"})
-        replayed, terminal = await second.events_after(record.run_id, 1, 0)
-
-        await first.release_lease(record.run_id)
-        recovered = await second.recoverable()
-        await second.complete(record.run_id, {"answer": "done"})
-        await first.append(record.run_id, "run.cancelled")
-        final = await first.get(record.run_id)
-
-        evaluation = await second.record_evaluation(
-            release_id(suffix),
-            "quality",
-            "1",
-            {"accuracy": 1.0},
-        )
-        repeated_evaluation = await first.record_evaluation(
-            release_id(suffix),
-            "quality",
-            "1",
-            {"accuracy": 1.0},
-        )
-
-        assert is_new is True
-        assert created.run_id == repeated.run_id
-        assert by_idempotency is not None
-        assert by_idempotency.run_id == created.run_id
-        assert repeated_is_new is False
-        assert [event["sequence"] for event in replayed] == [2]
-        assert terminal is False
-        assert recovered[0][0].run_id == record.run_id
-        assert final is not None
-        assert final.status == "completed"
-        assert [event["type"] for event in final.events].count("run.completed") == 1
-        assert evaluation == repeated_evaluation
-        await assert_encrypted(record.run_id, suffix)
-
-        conflict = fixture(f"{suffix}_other")
-        conflict.release = {
-            **cast(dict[str, JsonValue], conflict.release),
-            "releaseId": release_id(suffix),
-            "promptVersion": "changed",
-        }
-        with pytest.raises(IdempotencyConflictError):
-            await second.create_or_get(conflict)
-    finally:
-        await first.close()
-        await second.close()
-        await cleanup(suffix)
-
-
-def fixture(suffix: str) -> RunRecord:
-    return RunRecord(
-        run_id=f"run_{suffix}",
-        operation_key="test.echo",
-        input={"secret": f"sensitive-{suffix}"},
-        idempotency_key=f"key_{suffix}",
-        fingerprint=f"{suffix:0<64}"[:64],
-        release={
-            "releaseId": release_id(suffix),
-            "operationVersion": "1.0.0",
-            "workflowVersion": "workflow-1",
-            "promptVersion": "prompt-1",
-            "routeVersion": "route-1",
-            "outputSchemaVersion": "output-schema-1",
-            "toolSchemaVersion": "schema-1",
-            "manifestDigest": "0" * 64,
-        },
-        trace_id="1" * 32,
-    )
-
-
-def release_id(suffix: str) -> str:
-    return f"release_{suffix[:40]}"
-
-
-async def assert_encrypted(run_id: str, suffix: str) -> None:
-    async with await AsyncConnection.connect(DATABASE_URL) as connection:
-        cursor = await connection.execute(
-            """
-            select invocation_cipher, output_cipher from agent_runtime_runs
-            where run_id = %s
-            """,
-            (run_id,),
-        )
-        row = await cursor.fetchone()
-        assert row is not None
-        assert f"sensitive-{suffix}" not in str(row)
-
-
-async def cleanup(suffix: str) -> None:
-    async with await AsyncConnection.connect(DATABASE_URL) as connection:
-        await connection.execute(
-            "delete from agent_evaluation_results where release_id = %s",
-            (release_id(suffix),),
-        )
-        await connection.execute(
-            "delete from agent_runtime_runs where run_id like %s",
-            (f"run_{suffix}%",),
-        )
-        await connection.commit()

package/template/apps/agent-server/tests/test_provider_attempt_reporting.py

@@ -1,140 +0,0 @@
-from __future__ import annotations
-
-import httpx
-import pytest
-
-from southwind_agent_server.contracts import StartRunRequest
-from southwind_agent_server.engine import AgentEngineAdapter, SafeEngineError
-from southwind_agent_server.openai_engine import (
-    OpenAiCompatibleEngineAdapter,
-)
-from southwind_agent_server.report_store import (
-    InMemoryAgentRuntimeReportStore,
-)
-from southwind_agent_server.tool_host import ToolHostClient
-from tests.openai_provider_test_support import (
-    create_provider,
-    governance,
-    runtime_request,
-    sse_response,
-)
-
-
-async def test_blocked_response_preserves_provider_usage() -> None:
-    async def provider_handler(_request: httpx.Request) -> httpx.Response:
-        return sse_response(
-            [
-                {
-                    "model": "provider-model-v2",
-                    "choices": [
-                        {
-                            "delta": {
-                                "tool_calls": [
-                                    {
-                                        "index": 0,
-                                        "id": "call_bad",
-                                        "function": {
-                                            "name": "business.admin.delete",
-                                            "arguments": "{}",
-                                        },
-                                    }
-                                ]
-                            }
-                        }
-                    ],
-                    "usage": {
-                        "prompt_tokens": 10,
-                        "completion_tokens": 2,
-                        "total_tokens": 12,
-                        "prompt_tokens_details": {"cached_tokens": 5},
-                    },
-                }
-            ]
-        )
-
-    report = InMemoryAgentRuntimeReportStore(now=lambda: 200.0)
-    await report.ensure_run(
-        "run_1",
-        StartRunRequest(operation_key="business.answer", input=None),
-        100.0,
-    )
-    await report.start_run("run_1", 101.0)
-    provider = create_provider(httpx.MockTransport(provider_handler))
-    adapter: AgentEngineAdapter = OpenAiCompatibleEngineAdapter(
-        provider,
-        ToolHostClient("internal-token"),
-        governance(),
-        report,
-    )
-
-    with pytest.raises(SafeEngineError) as captured:
-        async for _ in adapter.execute(
-            runtime_request("business.records.list"),
-        ):
-            pass
-
-    detail = await report.get_run("run_1")
-    assert detail is not None
-    attempt = detail["attempts"][0]  # type: ignore[index]
-
-    assert captured.value.code == "TOOL_DENIED"
-    assert attempt["outcome"] == "blocked"
-    assert attempt["usageSource"] == "provider-reported"
-    assert attempt["inputTokens"] == 10
-    assert attempt["outputTokens"] == 2
-    assert attempt["cachedInputTokens"] == 5
-    assert attempt["totalTokens"] == 12
-    assert attempt["cacheStatus"] == "hit"
-    assert attempt["firstTokenLatencyMs"] is not None
-    assert attempt["model"] == "provider-model-v2"
-
-
-async def test_cancel_after_response_preserves_provider_usage() -> None:
-    adapter: AgentEngineAdapter
-
-    async def provider_handler(_request: httpx.Request) -> httpx.Response:
-        await adapter.cancel("run_1")
-        return sse_response(
-            [
-                {
-                    "model": "provider-model-v2",
-                    "choices": [{"delta": {"content": "late"}}],
-                    "usage": {
-                        "prompt_tokens": 3,
-                        "completion_tokens": 1,
-                        "total_tokens": 4,
-                    },
-                }
-            ]
-        )
-
-    report = InMemoryAgentRuntimeReportStore(now=lambda: 200.0)
-    await report.ensure_run(
-        "run_1",
-        StartRunRequest(operation_key="business.answer", input=None),
-        100.0,
-    )
-    await report.start_run("run_1", 101.0)
-    provider = create_provider(httpx.MockTransport(provider_handler))
-    adapter = OpenAiCompatibleEngineAdapter(
-        provider,
-        ToolHostClient("internal-token"),
-        governance(),
-        report,
-    )
-
-    with pytest.raises(SafeEngineError) as captured:
-        async for _ in adapter.execute(
-            runtime_request("business.records.list"),
-        ):
-            pass
-
-    detail = await report.get_run("run_1")
-    assert detail is not None
-    attempt = detail["attempts"][0]  # type: ignore[index]
-    assert captured.value.code == "RUN_CANCELLED"
-    assert attempt["outcome"] == "cancelled"
-    assert attempt["usageSource"] == "provider-reported"
-    assert attempt["totalTokens"] == 4
-    assert attempt["firstTokenLatencyMs"] is not None
-    assert attempt["model"] == "provider-model-v2"