create-windy 0.8.2 → 0.9.1

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

@@ -1,276 +0,0 @@
-from __future__ import annotations
-
-import sqlite3
-import time
-from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
-from typing import Literal, cast
-
-import pytest
-
-from southwind_agent_server.contracts import (
-    ProviderDataPolicy,
-    ProviderFieldPolicy,
-    ProviderInputFieldPolicy,
-)
-from southwind_agent_server.engine import SafeEngineError
-from southwind_agent_server.provider_audit import (
-    ProviderAttemptAudit,
-    ProviderAuditStore,
-)
-from southwind_agent_server.provider_governance import ProviderRequestGovernance
-
-
-def test_dlp_redacts_before_send_and_audits_metadata_only(tmp_path: Path) -> None:
-    path = tmp_path / "provider-audit.sqlite3"
-    governance = ProviderRequestGovernance(
-        ProviderAuditStore(str(path), retention_days=90)
-    )
-
-    result = governance.authorize(
-        deployment_key="ai.openai-compatible",
-        operation_key="business.answer",
-        run_id="run_1",
-        attempt=1,
-        messages=[
-            {"role": "system", "content": "只回答问题"},
-            {"role": "user", "content": "联系 me@example.com"},
-        ],
-        tools=(),
-        policy=policy(user_action="redact"),
-    )
-
-    assert result.messages[1]["content"] == "联系 [REDACTED]"
-    row = (
-        sqlite3.connect(path)
-        .execute(
-            """
-        select deployment_key, operation_key, run_id, attempt,
-          classifications, sent_bytes, decision
-        from provider_attempt_audit
-        """
-        )
-        .fetchone()
-    )
-    assert row == (
-        "ai.openai-compatible",
-        "business.answer",
-        "run_1",
-        1,
-        "internal",
-        row[5],
-        "redact",
-    )
-    assert row[5] > 0
-    assert "me@example.com" not in path.read_bytes().decode(errors="ignore")
-
-
-def test_missing_allowlist_and_dlp_reject_before_network(tmp_path: Path) -> None:
-    path = tmp_path / "provider-audit.sqlite3"
-    governance = ProviderRequestGovernance(
-        ProviderAuditStore(str(path), retention_days=90)
-    )
-
-    with pytest.raises(SafeEngineError) as missing:
-        governance.authorize(
-            deployment_key="ai.openai-compatible",
-            operation_key="business.answer",
-            run_id="run_missing",
-            attempt=1,
-            messages=[{"role": "system", "content": "只回答问题"}],
-            tools=(),
-            policy=ProviderDataPolicy(input_fields=[], envelope_fields=[]),
-        )
-    assert missing.value.code == "FORBIDDEN"
-
-    with pytest.raises(SafeEngineError) as rejected:
-        governance.authorize(
-            deployment_key="ai.openai-compatible",
-            operation_key="business.answer",
-            run_id="run_reject",
-            attempt=1,
-            messages=[
-                {"role": "system", "content": "只回答问题"},
-                {"role": "user", "content": "password=do-not-send"},
-            ],
-            tools=(),
-            policy=policy(user_action="reject"),
-        )
-    assert rejected.value.code == "FORBIDDEN"
-    decisions = (
-        sqlite3.connect(path)
-        .execute(
-            "select decision, sent_bytes from provider_attempt_audit "
-            "order by occurred_at"
-        )
-        .fetchall()
-    )
-    assert decisions == [("reject", 0), ("reject", 0)]
-
-
-def test_multimodal_attempt_requires_artifact_and_schema_allowlist(
-    tmp_path: Path,
-) -> None:
-    path = tmp_path / "provider-audit.sqlite3"
-    governance = ProviderRequestGovernance(
-        ProviderAuditStore(str(path), retention_days=90)
-    )
-    multimodal = policy(user_action="redact")
-    multimodal.envelope_fields.extend(
-        [
-            ProviderFieldPolicy(
-                field="artifact-content",
-                classification="sensitive",
-                dlp_action="reject",
-            ),
-            ProviderFieldPolicy(
-                field="output-schema",
-                classification="internal",
-                dlp_action="reject",
-            ),
-        ]
-    )
-    result = governance.authorize(
-        deployment_key="ai.openai-compatible",
-        operation_key="business.vision",
-        run_id="run_vision",
-        attempt=1,
-        messages=[
-            {"role": "system", "content": "只提取可见内容"},
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": "提取字段"},
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": "data:image/png;base64,AAAA",
-                            "detail": "auto",
-                        },
-                    },
-                ],
-            },
-        ],
-        tools=(),
-        policy=multimodal,
-        artifact_bytes=3,
-        output_schema={"type": "object"},
-    )
-    assert result.output_schema == {"type": "object"}
-    row = (
-        sqlite3.connect(path)
-        .execute(
-            "select classifications, sent_bytes, decision from provider_attempt_audit"
-        )
-        .fetchone()
-    )
-    assert row[0] == "internal,sensitive"
-    assert row[1] > 3
-    assert row[2] == "allow"
-
-
-def test_attempts_are_unique_append_only_and_ttl_purge_is_bounded(
-    tmp_path: Path,
-) -> None:
-    path = tmp_path / "provider-audit.sqlite3"
-    store = ProviderAuditStore(str(path), retention_days=1)
-    event = ProviderAttemptAudit(
-        "ai.openai-compatible",
-        "business.answer",
-        "run_1",
-        1,
-        ("internal",),
-        42,
-        "allow",
-    )
-    store.append(event)
-    with pytest.raises(sqlite3.IntegrityError):
-        store.append(event)
-
-    database = sqlite3.connect(path)
-    database.execute(
-        "update provider_attempt_audit set occurred_at = ?",
-        (time.time() - 2 * 24 * 60 * 60,),
-    )
-    database.commit()
-    database.close()
-
-    assert store.purge_expired() == 1
-    health = store.health()
-    assert health["retainedRecords"] == 0
-    assert health["lastDeletedRecords"] == 1
-    assert health["totalDeletedRecords"] == 1
-
-
-def test_audit_store_serializes_concurrent_single_replica_writes(
-    tmp_path: Path,
-) -> None:
-    store = ProviderAuditStore(
-        str(tmp_path / "provider-audit.sqlite3"),
-        retention_days=90,
-    )
-
-    def append(attempt: int) -> None:
-        store.append(
-            ProviderAttemptAudit(
-                "ai.openai-compatible",
-                "business.answer",
-                "run_concurrent",
-                attempt,
-                ("internal",),
-                42,
-                "allow",
-            )
-        )
-
-    with ThreadPoolExecutor(max_workers=4) as executor:
-        list(executor.map(append, range(1, 21)))
-
-    assert store.health()["retainedRecords"] == 20
-
-
-def test_audit_failure_denies_provider_attempt() -> None:
-    class BrokenAudit:
-        def append(self, _event: ProviderAttemptAudit) -> None:
-            raise sqlite3.OperationalError("do-not-expose")
-
-    governance = ProviderRequestGovernance(cast(ProviderAuditStore, BrokenAudit()))
-    with pytest.raises(SafeEngineError) as captured:
-        governance.authorize(
-            deployment_key="ai.openai-compatible",
-            operation_key="business.answer",
-            run_id="run_audit_failure",
-            attempt=1,
-            messages=[
-                {"role": "system", "content": "只回答问题"},
-                {"role": "user", "content": "正常内容"},
-            ],
-            tools=(),
-            policy=policy(user_action="redact"),
-        )
-    assert captured.value.code == "FORBIDDEN"
-    assert "do-not-expose" not in str(captured.value)
-
-
-def policy(*, user_action: Literal["reject", "redact"]) -> ProviderDataPolicy:
-    return ProviderDataPolicy(
-        input_fields=[
-            ProviderInputFieldPolicy(
-                json_pointer="/question",
-                classification="internal",
-                dlp_action="redact",
-            )
-        ],
-        envelope_fields=[
-            ProviderFieldPolicy(
-                field="instructions",
-                classification="internal",
-                dlp_action="reject",
-            ),
-            ProviderFieldPolicy(
-                field="user-prompt",
-                classification="internal",
-                dlp_action=user_action,
-            ),
-        ],
-    )

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

@@ -1,126 +0,0 @@
-from __future__ import annotations
-
-from southwind_agent_server.contracts import (
-    RunReportingContext,
-    StartRunRequest,
-)
-from southwind_agent_server.report_store import (
-    InMemoryAgentRuntimeReportStore,
-)
-from southwind_agent_server.report_types import ReportFilter, UsageFacts
-
-DAY = 24 * 60 * 60
-
-
-def request() -> StartRunRequest:
-    return StartRunRequest(
-        operation_key="business.answer",
-        input=None,
-        reporting=RunReportingContext(
-            actor_id="actor_1",
-            actor_type="user",
-        ),
-    )
-
-
-async def test_running_attempt_is_visible_but_excluded_from_summary() -> None:
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 4 * DAY)
-    await store.ensure_run("run_1", request(), 0)
-    await store.start_run("run_1", 1)
-    attempt = await store.start_attempt(
-        "run_1",
-        1,
-        "ai.openai-compatible",
-        "requested-model",
-        2 * DAY,
-    )
-
-    detail = await store.get_run("run_1")
-    summary = await store.summary(ReportFilter(0, 3 * DAY))
-
-    assert detail is not None
-    assert detail["attempts"][0]["outcome"] == "running"  # type: ignore[index]
-    assert detail["attempts"][0]["finishedAt"] is None  # type: ignore[index]
-    assert summary["cache"] == {
-        "hit": 0,
-        "miss": 0,
-        "unknown": 0,
-        "hitRate": None,
-        "tokenRate": None,
-        "coverageRate": 0,
-    }
-    assert summary["tokens"]["coverageRate"] == 0  # type: ignore[index]
-    assert summary["byModel"] == []
-
-    await store.start_run("run_1", 2 * DAY + 10)
-    recovered = await store.get_run("run_1")
-
-    assert recovered is not None
-    recovered_attempt = recovered["attempts"][0]  # type: ignore[index]
-    assert recovered_attempt["outcome"] == "abandoned"
-    assert recovered_attempt["finishedAt"] is not None
-    assert attempt.outcome == "running"
-
-
-async def test_attempt_metrics_use_attempt_day_not_run_day() -> None:
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 4 * DAY)
-    await store.ensure_run("run_1", request(), 0)
-    await store.start_run("run_1", 1)
-    attempt = await store.start_attempt(
-        "run_1",
-        1,
-        "ai.openai-compatible",
-        "requested-model",
-        2 * DAY,
-    )
-    await store.finish_attempt(
-        attempt.attempt_id,
-        "completed",
-        UsageFacts(
-            source="provider-reported",
-            input_tokens=10,
-            output_tokens=2,
-            total_tokens=12,
-            cache_status="miss",
-        ),
-        2 * DAY + 1,
-        "reported-model",
-    )
-    await store.finish_run("run_1", "completed", 2 * DAY + 2)
-
-    attempt_window = await store.summary(
-        ReportFilter(DAY, 3 * DAY),
-    )
-    whole_window = await store.summary(
-        ReportFilter(-1, 3 * DAY),
-    )
-
-    assert attempt_window["runs"]["total"] == 0  # type: ignore[index]
-    assert attempt_window["reportingAvailableFrom"] == "1970-01-03T00:00:00Z"
-    assert attempt_window["tokens"]["total"] == 12  # type: ignore[index]
-    assert attempt_window["byModel"][0]["attempts"] == 1  # type: ignore[index]
-    assert attempt_window["activity"] == [
-        {
-            "date": "1970-01-03",
-            "runs": 0,
-            "completed": 0,
-            "failed": 0,
-            "totalTokens": 12,
-        }
-    ]
-    assert whole_window["activity"] == [
-        {
-            "date": "1970-01-01",
-            "runs": 1,
-            "completed": 1,
-            "failed": 0,
-            "totalTokens": None,
-        },
-        {
-            "date": "1970-01-03",
-            "runs": 0,
-            "completed": 0,
-            "failed": 0,
-            "totalTokens": 12,
-        },
-    ]

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

@@ -1,183 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Literal, cast
-
-import httpx
-import pytest
-
-from southwind_agent_server.app import create_app
-from southwind_agent_server.contracts import StartRunRequest
-from southwind_agent_server.deterministic import DeterministicEngineAdapter
-from southwind_agent_server.engine import EngineCompleted
-from southwind_agent_server.engine_identity import DIRECT_ENGINE_ID
-from southwind_agent_server.openai_engine import OpenAiCompatibleEngineAdapter
-from southwind_agent_server.report_store import InMemoryAgentRuntimeReportStore
-from southwind_agent_server.report_types import (
-    AttemptReport,
-    AttemptTerminalOutcome,
-    UsageFacts,
-)
-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_report_store_outage_does_not_rewrite_canonical_terminal() -> None:
-    report_store = UnavailableRunReportStore()
-    application = create_app(
-        DeterministicEngineAdapter(),
-        heartbeat_seconds=0.01,
-        report_store=report_store,
-    )
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=application),
-        base_url="http://agent.test",
-    ) as client:
-        response = await client.post(
-            "/api/agent/runs",
-            headers={"Idempotency-Key": "report-store-outage"},
-            json={"operationKey": "test.echo", "input": {"text": "completed"}},
-        )
-        run_id = str(cast(dict[str, object], response.json())["runId"])
-        event_response = await client.get(f"/api/agent/runs/{run_id}/events")
-
-    emitted = events(event_response)
-    assert emitted[-1]["type"] == "run.completed"
-    assert "run.failed" not in {event["type"] for event in emitted}
-    rendered = report_store.metrics.render()
-    for stage in ("run_ensure", "run_start", "run_terminal"):
-        assert (
-            f'southwind_agent_runtime_reporting_failures_total{{stage="{stage}"}} 1'
-            in rendered
-        )
-
-
-@pytest.mark.parametrize("failure_stage", ["attempt_start", "attempt_terminal"])
-async def test_report_store_outage_does_not_block_model_request(
-    failure_stage: Literal["attempt_start", "attempt_terminal"],
-) -> None:
-    provider_calls = 0
-
-    async def provider_handler(_request: httpx.Request) -> httpx.Response:
-        nonlocal provider_calls
-        provider_calls += 1
-        return sse_response([{"choices": [{"delta": {"content": "完成"}}]}])
-
-    report_store = FailingAttemptReportStore(failure_stage)
-    engine = OpenAiCompatibleEngineAdapter(
-        create_provider(httpx.MockTransport(provider_handler)),
-        ToolHostClient("internal-token"),
-        governance(),
-        report_store,
-    )
-
-    signals = [
-        signal
-        async for signal in engine.execute(runtime_request("business.records.list"))
-    ]
-
-    assert provider_calls == 1
-    assert isinstance(signals[-1], EngineCompleted)
-    assert (
-        "southwind_agent_runtime_reporting_failures_total"
-        f'{{stage="{failure_stage}"}} 1' in report_store.metrics.render()
-    )
-
-
-class UnavailableRunReportStore(InMemoryAgentRuntimeReportStore):
-    async def ensure_run(
-        self,
-        run_id: str,
-        request: StartRunRequest,
-        created_at: float,
-        engine_id: str = DIRECT_ENGINE_ID,
-    ) -> None:
-        raise RuntimeError("report store unavailable")
-
-    async def start_run(self, run_id: str, started_at: float) -> None:
-        raise RuntimeError("report store unavailable")
-
-    async def set_run_status(
-        self,
-        run_id: str,
-        status: Literal["running", "awaiting-approval"],
-        updated_at: float,
-    ) -> None:
-        raise RuntimeError("report store unavailable")
-
-    async def finish_run(
-        self,
-        run_id: str,
-        status: Literal["completed", "failed", "cancelled"],
-        finished_at: float,
-        safe_error_code: str | None = None,
-    ) -> None:
-        raise RuntimeError("report store unavailable")
-
-
-class FailingAttemptReportStore(InMemoryAgentRuntimeReportStore):
-    def __init__(
-        self,
-        failure_stage: Literal["attempt_start", "attempt_terminal"],
-    ) -> None:
-        super().__init__()
-        self.failure_stage = failure_stage
-
-    async def start_attempt(
-        self,
-        run_id: str,
-        tool_round: int,
-        deployment_key: str,
-        requested_model: str,
-        started_at: float,
-    ) -> AttemptReport:
-        if self.failure_stage == "attempt_start":
-            raise RuntimeError("report store unavailable")
-        return await super().start_attempt(
-            run_id,
-            tool_round,
-            deployment_key,
-            requested_model,
-            started_at,
-        )
-
-    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:
-        if self.failure_stage == "attempt_terminal":
-            raise RuntimeError("report store unavailable")
-        await super().finish_attempt(
-            attempt_id,
-            outcome,
-            usage,
-            finished_at,
-            reported_model,
-            safe_error_code,
-        )
-
-
-def events(response: httpx.Response) -> list[dict[str, object]]:
-    result: list[dict[str, object]] = []
-    for frame in response.text.split("\n\n"):
-        data = next(
-            (
-                line.removeprefix("data: ")
-                for line in frame.splitlines()
-                if line.startswith("data: ")
-            ),
-            None,
-        )
-        if data is not None:
-            result.append(json.loads(data))
-    return result