create-windy 0.8.3 → 0.9.1

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

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-import httpx
-import pytest
-from fastapi import FastAPI
-
-from southwind_agent_server.contracts import RunReportingContext, StartRunRequest
-from southwind_agent_server.report_routes import create_report_router
-from southwind_agent_server.report_store import InMemoryAgentRuntimeReportStore
-from southwind_agent_server.report_types import UsageFacts
-from southwind_agent_server.store import InMemoryRunStore, RunRecord
-
-
-async def test_internal_run_routes_project_model_deployments_and_facts(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr("southwind_agent_server.report_routes.time.time", lambda: 400.0)
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    await store.ensure_run(
-        "run_1",
-        StartRunRequest(
-            operation_key="business.answer",
-            input=None,
-            reporting=RunReportingContext(
-                actor_id="actor_1", actor_type="user", department_id=None
-            ),
-        ),
-        100.0,
-    )
-    attempt = await store.start_attempt(
-        "run_1", 1, "ai.primary", "requested-model", 101.0
-    )
-    await store.finish_attempt(
-        attempt.attempt_id,
-        "completed",
-        UsageFacts(total_tokens=12),
-        102.0,
-        "provider-model-v2",
-    )
-    run_store = InMemoryRunStore()
-    await run_store.create_or_get(
-        RunRecord(
-            run_id="run_1",
-            operation_key="business.answer",
-            input={"prompt": "不应出现在轨迹中"},
-            idempotency_key="idem_1",
-            fingerprint="fingerprint_1",
-            engine_id="windy.direct.openai-compatible.v1",
-            release={"releaseId": "legacy"},
-            events=[
-                {"type": "run.started", "runId": "run_1", "sequence": 1},
-                {
-                    "type": "output.delta",
-                    "runId": "run_1",
-                    "sequence": 2,
-                    "text": "机密输出",
-                },
-                {
-                    "type": "usage.reported",
-                    "runId": "run_1",
-                    "sequence": 3,
-                    "attemptSequence": 1,
-                    "usage": {"totalTokens": 12},
-                },
-            ],
-        )
-    )
-    application = FastAPI()
-    application.include_router(create_report_router(store, run_store, "internal-token"))
-
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=application), base_url="http://test"
-    ) as client:
-        headers = {"Authorization": "Bearer internal-token"}
-        listed = await client.get(
-            "/api/internal/ai-runtime-report/runs?range=retained&scopeMode=all",
-            headers=headers,
-        )
-        detail = await client.get(
-            "/api/internal/ai-runtime-report/runs/run_1", headers=headers
-        )
-
-    assert listed.status_code == 200
-    assert listed.json()["items"][0]["modelDeployments"] == [
-        {
-            "deploymentKey": "ai.primary",
-            "model": "provider-model-v2",
-            "attemptCount": 1,
-        }
-    ]
-    assert detail.status_code == 200
-    assert detail.json()["attempts"] == [
-        {
-            "attemptId": attempt.attempt_id,
-            "sequence": 1,
-            "toolRound": 1,
-            "deploymentKey": "ai.primary",
-            "requestedModel": "requested-model",
-            "reportedModel": "provider-model-v2",
-            "model": "provider-model-v2",
-            "outcome": "completed",
-            "cacheStatus": "unknown",
-            "usageSource": "unknown",
-            "inputTokens": None,
-            "outputTokens": None,
-            "cachedInputTokens": None,
-            "reasoningTokens": None,
-            "totalTokens": 12,
-            "firstTokenLatencyMs": None,
-            "durationMs": 1000,
-            "safeErrorCode": None,
-            "startedAt": "1970-01-01T00:01:41Z",
-            "finishedAt": "1970-01-01T00:01:42Z",
-        }
-    ]
-    assert detail.json()["trajectory"] == {
-        "available": True,
-        "events": [
-            {
-                "sequence": 1,
-                "sequenceEnd": 1,
-                "type": "run.started",
-                "title": "开始执行",
-            },
-            {
-                "sequence": 2,
-                "sequenceEnd": 2,
-                "type": "output.delta",
-                "title": "模型生成输出",
-                "deltaCount": 1,
-                "outputCharacters": 4,
-            },
-            {
-                "sequence": 3,
-                "sequenceEnd": 3,
-                "type": "usage.reported",
-                "title": "Provider 用量已上报",
-                "attemptSequence": 1,
-                "totalTokens": 12,
-            },
-        ],
-    }
-    assert "机密输出" not in detail.text

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

@@ -1,347 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Literal, cast
-
-import pytest
-
-from southwind_agent_server.contracts import (
-    RunReportingContext,
-    StartRunRequest,
-)
-from southwind_agent_server.postgres_report_insert import (
-    RUN_INSERT_SQL,
-    run_insert_values,
-)
-from southwind_agent_server.report_lifecycle import sync_status
-from southwind_agent_server.report_store import InMemoryAgentRuntimeReportStore
-from southwind_agent_server.report_types import ReportFilter, UsageFacts
-
-
-def request(actor_id: str) -> StartRunRequest:
-    return StartRunRequest(
-        operation_key="business.answer",
-        input={"secret": "must-not-be-reported"},
-        reporting=RunReportingContext(
-            actor_id=actor_id,
-            actor_type="user",
-            department_id="department_1",
-        ),
-    )
-
-
-def test_postgres_run_insert_binds_every_persisted_timestamp() -> None:
-    values = run_insert_values("run_1", request("actor_1"), 100.0, 90)
-
-    assert RUN_INSERT_SQL.count("%s") == len(values)
-    assert values[-3:] == (100.0, 100.0, 7_776_100.0)
-
-
-async def test_summary_rates_exclude_cancelled_and_unknown_cache() -> None:
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    values: tuple[tuple[str, str, Literal["completed", "failed", "cancelled"]], ...] = (
-        ("run_completed", "actor_1", "completed"),
-        ("run_failed", "actor_2", "failed"),
-        ("run_cancelled", "actor_3", "cancelled"),
-    )
-    for run_id, actor_id, status in values:
-        await store.ensure_run(run_id, request(actor_id), 100.0)
-        await store.start_run(run_id, 101.0)
-        await store.finish_run(run_id, status, 102.0)
-
-    attempts = (
-        ("run_completed", UsageFacts(cache_status="hit")),
-        ("run_failed", UsageFacts(cache_status="miss")),
-        ("run_cancelled", UsageFacts()),
-    )
-    for run_id, usage in attempts:
-        attempt = await store.start_attempt(
-            run_id,
-            1,
-            "ai.openai-compatible",
-            "requested-model",
-            101.0,
-        )
-        await store.finish_attempt(
-            attempt.attempt_id,
-            "completed",
-            usage,
-            102.0,
-        )
-
-    summary = await store.summary(ReportFilter(0, 500))
-
-    assert summary["runs"] == {
-        "total": 3,
-        "completed": 1,
-        "failed": 1,
-        "cancelled": 1,
-        "inProgress": 0,
-        "successRate": 0.5,
-    }
-    assert summary["cache"] == {
-        "hit": 1,
-        "miss": 1,
-        "unknown": 1,
-        "hitRate": 0.5,
-        "tokenRate": None,
-        "coverageRate": 2 / 3,
-    }
-
-
-async def test_approval_status_transitions_and_terminal_never_regresses() -> None:
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    await store.ensure_run("run_1", request("actor_1"), 100.0)
-    await store.start_run("run_1", 101.0)
-
-    await sync_status(store, "run_1", "approval.required")
-    waiting = await store.get_run("run_1")
-    assert waiting is not None
-    assert waiting["status"] == "awaiting-approval"
-
-    await sync_status(store, "run_1", "approval.resolved")
-    resumed = await store.get_run("run_1")
-    assert resumed is not None
-    assert resumed["status"] == "running"
-
-    await store.finish_run("run_1", "completed", 104.0)
-    await sync_status(store, "run_1", "approval.required")
-    terminal = await store.get_run("run_1")
-    assert terminal is not None
-    assert terminal["status"] == "completed"
-
-
-async def test_unknown_usage_stays_null_and_empty_history_has_no_origin() -> None:
-    empty = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    empty_summary = await empty.summary(ReportFilter(0, 500))
-    assert empty_summary["reportingAvailableFrom"] is None
-
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    await store.ensure_run("run_1", request("actor_secret"), 100.0)
-    attempt = await store.start_attempt(
-        "run_1",
-        1,
-        "ai.openai-compatible",
-        "requested-model",
-        101.0,
-    )
-    await store.finish_attempt(
-        attempt.attempt_id,
-        "completed",
-        UsageFacts(),
-        102.0,
-    )
-
-    detail = await store.get_run("run_1")
-
-    assert detail is not None
-    assert detail["usage"] == {
-        "inputTokens": None,
-        "outputTokens": None,
-        "cachedInputTokens": None,
-        "reasoningTokens": None,
-        "totalTokens": None,
-    }
-    rendered_metrics = store.metrics.render()
-    assert "actor_secret" not in rendered_metrics
-    assert "requested-model" not in rendered_metrics
-
-
-async def test_reporting_origin_is_limited_to_filter_and_scope() -> None:
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    await store.ensure_run("run_other", request("actor_other"), 100.0)
-    await store.ensure_run("run_visible", request("actor_visible"), 200.0)
-
-    selected = await store.summary(
-        ReportFilter(0, 500, selected_actor_id="actor_visible")
-    )
-    scoped = await store.summary(
-        ReportFilter(
-            0,
-            500,
-            scope_restricted=True,
-            actor_ids=("actor_visible",),
-        )
-    )
-    empty = await store.summary(
-        ReportFilter(
-            0,
-            500,
-            scope_restricted=True,
-            actor_ids=("actor_missing",),
-        )
-    )
-
-    assert selected["reportingAvailableFrom"] == "1970-01-01T00:03:20Z"
-    assert scoped["reportingAvailableFrom"] == "1970-01-01T00:03:20Z"
-    assert empty["reportingAvailableFrom"] is None
-
-
-async def test_attempt_terminal_replay_rejects_changed_facts() -> None:
-    store = InMemoryAgentRuntimeReportStore()
-    attempt = await store.start_attempt(
-        "run_1",
-        1,
-        "ai.openai-compatible",
-        "requested-model",
-        100.0,
-    )
-    usage = UsageFacts(
-        source="provider-reported",
-        input_tokens=10,
-        total_tokens=10,
-    )
-    await store.finish_attempt(
-        attempt.attempt_id,
-        "completed",
-        usage,
-        101.0,
-        "reported-model",
-    )
-    await store.finish_attempt(
-        attempt.attempt_id,
-        "completed",
-        usage,
-        102.0,
-        "reported-model",
-    )
-
-    with pytest.raises(ValueError, match="Attempt 终态冲突"):
-        await store.finish_attempt(
-            attempt.attempt_id,
-            "completed",
-            usage,
-            103.0,
-            "different-model",
-        )
-
-
-async def test_token_rates_only_use_attempts_with_matching_known_facts() -> None:
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    await store.ensure_run("run_1", request("actor_1"), 100.0)
-    for usage in (
-        UsageFacts(
-            source="provider-reported",
-            input_tokens=10,
-            cached_input_tokens=None,
-            total_tokens=None,
-            cache_status="unknown",
-        ),
-        UsageFacts(
-            source="provider-reported",
-            input_tokens=10,
-            cached_input_tokens=5,
-            total_tokens=15,
-            cache_status="hit",
-        ),
-    ):
-        attempt = await store.start_attempt(
-            "run_1",
-            1,
-            "ai.openai-compatible",
-            "requested-model",
-            101.0,
-        )
-        await store.finish_attempt(
-            attempt.attempt_id,
-            "completed",
-            usage,
-            102.0,
-        )
-
-    summary = await store.summary(ReportFilter(0, 500))
-
-    assert summary["cache"]["tokenRate"] == 0.5  # type: ignore[index]
-    assert summary["tokens"]["coverageRate"] == 0.5  # type: ignore[index]
-    assert summary["activity"][0]["totalTokens"] is None  # type: ignore[index]
-
-
-async def test_completely_unknown_aggregate_tokens_stay_null() -> None:
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    await store.ensure_run("run_1", request("actor_1"), 100.0)
-    attempt = await store.start_attempt(
-        "run_1",
-        1,
-        "ai.openai-compatible",
-        "requested-model",
-        101.0,
-    )
-    await store.finish_attempt(
-        attempt.attempt_id,
-        "completed",
-        UsageFacts(),
-        102.0,
-    )
-
-    summary = await store.summary(ReportFilter(0, 500))
-
-    assert summary["tokens"] == {
-        "input": None,
-        "output": None,
-        "cachedInput": None,
-        "reasoning": None,
-        "total": None,
-        "coverageRate": 0,
-    }
-    assert summary["byModel"][0]["totalTokens"] is None  # type: ignore[index]
-    assert summary["activity"][0]["totalTokens"] is None  # type: ignore[index]
-
-
-async def test_run_projection_keeps_model_deployment_combinations_and_facts() -> None:
-    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
-    await store.ensure_run("run_empty", request("actor_1"), 90.0)
-    await store.ensure_run("run_1", request("actor_1"), 100.0)
-
-    first = await store.start_attempt(
-        "run_1", 1, "ai.primary", "requested-primary", 101.0
-    )
-    await store.start_attempt("run_1", 2, "ai.fallback", "requested-fallback", 102.0)
-    third = await store.start_attempt(
-        "run_1", 3, "ai.primary", "requested-primary", 103.0
-    )
-    await store.finish_attempt(
-        first.attempt_id,
-        "completed",
-        UsageFacts(),
-        104.0,
-        "provider-primary-v2",
-    )
-    await store.finish_attempt(third.attempt_id, "failed", UsageFacts(), 105.0)
-
-    page = await store.list_runs(ReportFilter(0, 500), 1, 20)
-    items = cast(list[dict[str, Any]], page["items"])
-    item = items[0]
-    assert item["modelDeployments"] == [
-        {
-            "deploymentKey": "ai.primary",
-            "model": "provider-primary-v2",
-            "attemptCount": 1,
-        },
-        {
-            "deploymentKey": "ai.fallback",
-            "model": "requested-fallback",
-            "attemptCount": 1,
-        },
-        {
-            "deploymentKey": "ai.primary",
-            "model": "requested-primary",
-            "attemptCount": 1,
-        },
-    ]
-    assert items[1]["modelDeployments"] == []
-
-    detail = await store.get_run("run_1")
-    assert detail is not None
-    attempts = cast(list[dict[str, Any]], detail["attempts"])
-    assert [
-        (
-            attempt["sequence"],
-            attempt["deploymentKey"],
-            attempt["requestedModel"],
-            attempt["reportedModel"],
-        )
-        for attempt in attempts
-    ] == [
-        (1, "ai.primary", "requested-primary", "provider-primary-v2"),
-        (2, "ai.fallback", "requested-fallback", None),
-        (3, "ai.primary", "requested-primary", None),
-    ]

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

@@ -1,116 +0,0 @@
-from __future__ import annotations
-
-from southwind_agent_server.postgres_report_summary import present_summary
-from southwind_agent_server.report_presenter import aggregate_summary
-from southwind_agent_server.report_types import (
-    AttemptReport,
-    RunReport,
-    UsageFacts,
-)
-
-
-def test_postgres_and_in_memory_summary_present_same_dual_timeline() -> None:
-    run = RunReport(
-        run_id="run_1",
-        engine_id="windy.direct.openai-compatible.v1",
-        operation_key="business.answer",
-        release_id="release_1",
-        trace_id="trace_1",
-        actor_id="actor_1",
-        actor_type="user",
-        department_id=None,
-        status="completed",
-        safe_error_code=None,
-        started_at=1,
-        finished_at=2,
-        duration_ms=1_000,
-        created_at=0,
-        updated_at=2,
-        expires_at=1_000,
-    )
-    usage = UsageFacts(
-        source="provider-reported",
-        input_tokens=10,
-        output_tokens=2,
-        cached_input_tokens=5,
-        total_tokens=12,
-        cache_status="hit",
-    )
-    attempt = AttemptReport(
-        attempt_id="attempt_1",
-        run_id="run_1",
-        sequence=1,
-        tool_round=1,
-        deployment_key="ai.openai-compatible",
-        requested_model="requested",
-        reported_model="reported",
-        outcome="completed",
-        usage=usage,
-        duration_ms=1_000,
-        safe_error_code=None,
-        started_at=172_800,
-        finished_at=172_801,
-    )
-
-    memory = aggregate_summary([run], [attempt], 90, 0, 400)
-    postgres = present_summary(
-        {
-            "total": 1,
-            "completed": 1,
-            "failed": 0,
-            "cancelled": 0,
-            "available_from": 0,
-        },
-        {
-            "attempts": 1,
-            "available_from": 172_800,
-            "cache_hit": 1,
-            "cache_miss": 0,
-            "cache_unknown": 0,
-            "known_total_tokens": 1,
-            "input_tokens": 10,
-            "output_tokens": 2,
-            "cached_input_tokens": 5,
-            "reasoning_tokens": None,
-            "total_tokens": 12,
-            "paired_input_tokens": 10,
-            "paired_cached_tokens": 5,
-        },
-        [
-            {
-                "deployment_key": "ai.openai-compatible",
-                "model": "reported",
-                "attempts": 1,
-                "input_tokens": 10,
-                "output_tokens": 2,
-                "cached_input_tokens": 5,
-                "reasoning_tokens": None,
-                "total_tokens": 12,
-                "unknown_usage_count": 0,
-            }
-        ],
-        [
-            {
-                "date": "1970-01-01",
-                "runs": 1,
-                "completed": 1,
-                "failed": 0,
-                "attempts": 0,
-                "known_token_attempts": 0,
-                "total_tokens": None,
-            },
-            {
-                "date": "1970-01-03",
-                "runs": 0,
-                "completed": 0,
-                "failed": 0,
-                "attempts": 1,
-                "known_token_attempts": 1,
-                "total_tokens": 12,
-            },
-        ],
-        90,
-        400,
-    )
-
-    assert postgres == memory