create-windy 0.4.1 → 0.5.1

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

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from datetime import UTC, datetime
+from typing import cast
+
+from .report_types import (
+    AttemptReport,
+    CacheStatus,
+    ReportFilter,
+    RunReport,
+    iso,
+)
+
+
+def filtered_runs(values: Iterable[RunReport], query: ReportFilter) -> list[RunReport]:
+    return [
+        run
+        for run in scoped_runs(values, query)
+        if query.from_timestamp <= run.created_at <= query.to_timestamp
+    ]
+
+
+def scoped_runs(values: Iterable[RunReport], query: ReportFilter) -> list[RunReport]:
+    return [
+        run
+        for run in values
+        if (query.selected_actor_id is None or run.actor_id == query.selected_actor_id)
+        and (
+            not query.scope_restricted
+            or run.actor_id in query.actor_ids
+            or run.department_id in query.department_ids
+        )
+    ]
+
+
+def attempts_for(
+    values: Iterable[AttemptReport], runs: Iterable[RunReport]
+) -> list[AttemptReport]:
+    run_ids = {run.run_id for run in runs}
+    return sorted(
+        [item for item in values if item.run_id in run_ids],
+        key=lambda item: (item.run_id, item.sequence),
+    )
+
+
+def filtered_attempts(
+    values: Iterable[AttemptReport],
+    runs: Iterable[RunReport],
+    query: ReportFilter,
+) -> list[AttemptReport]:
+    return [
+        attempt
+        for attempt in attempts_for(values, runs)
+        if attempt.finished_at is not None
+        and query.from_timestamp <= attempt.started_at <= query.to_timestamp
+    ]
+
+
+def aggregate_summary(
+    runs: list[RunReport],
+    attempts: list[AttemptReport],
+    retention_days: int,
+    available_from: float | None,
+    generated_at: float,
+) -> dict[str, object]:
+    attempts = [item for item in attempts if item.finished_at is not None]
+    completed = count_status(runs, "completed")
+    failed = count_status(runs, "failed")
+    cancelled = count_status(runs, "cancelled")
+    denominator = completed + failed
+    hit = count_cache(attempts, "hit")
+    miss = count_cache(attempts, "miss")
+    unknown = count_cache(attempts, "unknown")
+    cache_pairs = [
+        item
+        for item in attempts
+        if item.usage.input_tokens is not None
+        and item.usage.cached_input_tokens is not None
+    ]
+    paired_input_tokens = sum_known(cache_pairs, "input_tokens")
+    paired_cached_tokens = sum_known(cache_pairs, "cached_input_tokens")
+    known_total_tokens = sum(item.usage.total_tokens is not None for item in attempts)
+    return {
+        "generatedAt": iso(generated_at),
+        "reportingAvailableFrom": iso(available_from),
+        "retentionDays": retention_days,
+        "runs": {
+            "total": len(runs),
+            "completed": completed,
+            "failed": failed,
+            "cancelled": cancelled,
+            "inProgress": len(runs) - completed - failed - cancelled,
+            "successRate": completed / denominator if denominator else None,
+        },
+        "cache": {
+            "hit": hit,
+            "miss": miss,
+            "unknown": unknown,
+            "hitRate": hit / (hit + miss) if hit + miss else None,
+            "tokenRate": (
+                paired_cached_tokens / paired_input_tokens
+                if paired_input_tokens > 0
+                else None
+            ),
+            "coverageRate": (hit + miss) / len(attempts) if attempts else 0,
+        },
+        "tokens": {
+            "input": sum_reported(attempts, "input_tokens"),
+            "output": sum_reported(attempts, "output_tokens"),
+            "cachedInput": sum_reported(attempts, "cached_input_tokens"),
+            "reasoning": sum_reported(attempts, "reasoning_tokens"),
+            "total": sum_reported(attempts, "total_tokens"),
+            "coverageRate": (known_total_tokens / len(attempts) if attempts else 0),
+        },
+        "byModel": by_model(attempts),
+        "activity": activity(runs, attempts),
+    }
+
+
+def count_status(runs: list[RunReport], status: str) -> int:
+    return sum(run.status == status for run in runs)
+
+
+def count_cache(attempts: list[AttemptReport], status: CacheStatus) -> int:
+    return sum(item.usage.cache_status == status for item in attempts)
+
+
+def sum_known(attempts: list[AttemptReport], field: str) -> int:
+    return sum(
+        value for item in attempts if (value := getattr(item.usage, field)) is not None
+    )
+
+
+def sum_reported(attempts: list[AttemptReport], field: str) -> int | None:
+    values = [
+        cast(int, value)
+        for item in attempts
+        if (value := getattr(item.usage, field)) is not None
+    ]
+    if values:
+        return sum(values)
+    return 0 if not attempts else None
+
+
+def by_model(attempts: list[AttemptReport]) -> list[dict[str, object]]:
+    groups: dict[tuple[str, str], list[AttemptReport]] = {}
+    for item in attempts:
+        model = item.reported_model or item.requested_model
+        groups.setdefault((item.deployment_key, model), []).append(item)
+    return [
+        {
+            "deploymentKey": deployment,
+            "model": model,
+            "attempts": len(items),
+            "inputTokens": sum_reported(items, "input_tokens"),
+            "outputTokens": sum_reported(items, "output_tokens"),
+            "cachedInputTokens": sum_reported(items, "cached_input_tokens"),
+            "reasoningTokens": sum_reported(items, "reasoning_tokens"),
+            "totalTokens": sum_reported(items, "total_tokens"),
+            "unknownUsageCount": sum(item.usage.source == "unknown" for item in items),
+        }
+        for (deployment, model), items in sorted(groups.items())
+    ]
+
+
+def activity(
+    runs: list[RunReport], attempts: list[AttemptReport]
+) -> list[dict[str, object]]:
+    result: dict[str, dict[str, int]] = {}
+    for run in runs:
+        day = datetime.fromtimestamp(run.created_at, tz=UTC).date().isoformat()
+        row = result.setdefault(
+            day,
+            {
+                "runs": 0,
+                "completed": 0,
+                "failed": 0,
+                "totalTokens": 0,
+                "tokenAttempts": 0,
+                "knownTokenAttempts": 0,
+            },
+        )
+        row["runs"] += 1
+        row["completed"] += int(run.status == "completed")
+        row["failed"] += int(run.status == "failed")
+    for attempt in attempts:
+        day = datetime.fromtimestamp(attempt.started_at, tz=UTC).date().isoformat()
+        row = result.setdefault(
+            day,
+            {
+                "runs": 0,
+                "completed": 0,
+                "failed": 0,
+                "totalTokens": 0,
+                "tokenAttempts": 0,
+                "knownTokenAttempts": 0,
+            },
+        )
+        row["tokenAttempts"] += 1
+        if attempt.usage.total_tokens is not None:
+            row["totalTokens"] += attempt.usage.total_tokens
+            row["knownTokenAttempts"] += 1
+    return [
+        {
+            "date": day,
+            "runs": result[day]["runs"],
+            "completed": result[day]["completed"],
+            "failed": result[day]["failed"],
+            "totalTokens": (
+                result[day]["totalTokens"]
+                if result[day]["tokenAttempts"]
+                and result[day]["knownTokenAttempts"] == result[day]["tokenAttempts"]
+                else None
+            ),
+        }
+        for day in sorted(result)
+    ]
+
+
+def run_value(run: RunReport, attempts: list[AttemptReport]) -> dict[str, object]:
+    models = sorted({item.reported_model or item.requested_model for item in attempts})
+    cache = (
+        "hit"
+        if any(item.usage.cache_status == "hit" for item in attempts)
+        else "miss"
+        if any(item.usage.cache_status == "miss" for item in attempts)
+        else "unknown"
+    )
+    return {
+        "runId": run.run_id,
+        "operationKey": run.operation_key,
+        "actorId": run.actor_id,
+        "departmentId": run.department_id,
+        "status": run.status,
+        "startedAt": iso(run.started_at),
+        "finishedAt": iso(run.finished_at),
+        "durationMs": run.duration_ms,
+        "attemptCount": len(attempts),
+        "models": models,
+        "cacheStatus": cache,
+        "usage": usage_value(attempts),
+    }
+
+
+def usage_value(attempts: list[AttemptReport]) -> dict[str, int | None]:
+    def total(field: str) -> int | None:
+        values = [
+            value
+            for item in attempts
+            if (value := getattr(item.usage, field)) is not None
+        ]
+        return sum(values) if values else None
+
+    return {
+        "inputTokens": total("input_tokens"),
+        "outputTokens": total("output_tokens"),
+        "cachedInputTokens": total("cached_input_tokens"),
+        "reasoningTokens": total("reasoning_tokens"),
+        "totalTokens": total("total_tokens"),
+    }
+
+
+def attempt_value(item: AttemptReport) -> dict[str, object]:
+    return {
+        "attemptId": item.attempt_id,
+        "sequence": item.sequence,
+        "toolRound": item.tool_round,
+        "deploymentKey": item.deployment_key,
+        "model": item.reported_model or item.requested_model,
+        "outcome": item.outcome,
+        "cacheStatus": item.usage.cache_status,
+        "usageSource": item.usage.source,
+        **usage_value([item]),
+        "firstTokenLatencyMs": item.usage.first_token_latency_ms,
+        "durationMs": item.duration_ms,
+        "safeErrorCode": item.safe_error_code,
+        "startedAt": iso(item.started_at),
+        "finishedAt": iso(item.finished_at),
+    }

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

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import time
+from typing import Annotated, Literal
+
+from fastapi import APIRouter, Header, Query
+from fastapi.responses import JSONResponse, PlainTextResponse
+
+from .http_helpers import authorized, safe_error
+from .report_store import AgentRuntimeReportStore
+from .report_types import ReportFilter
+
+type ReportRange = Literal["day", "month", "retained"]
+type ScopeMode = Literal["all", "bounded", "none"]
+
+
+def create_report_router(
+    store: AgentRuntimeReportStore,
+    internal_token: str | None,
+) -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/metrics", response_model=None)
+    async def metrics() -> PlainTextResponse:
+        return PlainTextResponse(
+            store.metrics.render(),
+            media_type="text/plain; version=0.0.4; charset=utf-8",
+            headers={"Cache-Control": "no-store"},
+        )
+
+    @router.get("/api/internal/ai-runtime-report/summary", response_model=None)
+    async def report_summary(
+        range_name: Annotated[ReportRange, Query(alias="range")] = "day",
+        actor_id: Annotated[str | None, Query(alias="actorId", max_length=64)] = None,
+        scope_actor_ids: Annotated[
+            list[str] | None, Query(alias="scopeActorId", max_length=64)
+        ] = None,
+        scope_department_ids: Annotated[
+            list[str] | None, Query(alias="scopeDepartmentId", max_length=64)
+        ] = None,
+        scope_mode: Annotated[ScopeMode, Query(alias="scopeMode")] = "none",
+        authorization: Annotated[str | None, Header()] = None,
+    ) -> dict[str, object] | JSONResponse:
+        if not authorized(authorization, internal_token):
+            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
+        return await store.summary(
+            report_filter(
+                store,
+                range_name,
+                actor_id,
+                scope_mode,
+                scope_actor_ids,
+                scope_department_ids,
+            )
+        )
+
+    @router.get("/api/internal/ai-runtime-report/runs", response_model=None)
+    async def report_runs(
+        range_name: Annotated[ReportRange, Query(alias="range")] = "day",
+        actor_id: Annotated[str | None, Query(alias="actorId", max_length=64)] = None,
+        scope_actor_ids: Annotated[
+            list[str] | None, Query(alias="scopeActorId", max_length=64)
+        ] = None,
+        scope_department_ids: Annotated[
+            list[str] | None, Query(alias="scopeDepartmentId", max_length=64)
+        ] = None,
+        scope_mode: Annotated[ScopeMode, Query(alias="scopeMode")] = "none",
+        page: Annotated[int, Query(ge=1)] = 1,
+        page_size: Annotated[int, Query(alias="pageSize", ge=1, le=100)] = 20,
+        authorization: Annotated[str | None, Header()] = None,
+    ) -> dict[str, object] | JSONResponse:
+        if not authorized(authorization, internal_token):
+            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
+        return await store.list_runs(
+            report_filter(
+                store,
+                range_name,
+                actor_id,
+                scope_mode,
+                scope_actor_ids,
+                scope_department_ids,
+            ),
+            page,
+            page_size,
+        )
+
+    @router.get(
+        "/api/internal/ai-runtime-report/runs/{run_id}",
+        response_model=None,
+    )
+    async def report_run(
+        run_id: str,
+        authorization: Annotated[str | None, Header()] = None,
+    ) -> dict[str, object] | JSONResponse:
+        if not authorized(authorization, internal_token):
+            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
+        value = await store.get_run(run_id)
+        if value is None:
+            return safe_error(404, "RUN_CONFLICT", "Agent Run 不存在", False)
+        return value
+
+    return router
+
+
+def report_filter(
+    store: AgentRuntimeReportStore,
+    range_name: ReportRange,
+    actor_id: str | None,
+    scope_mode: ScopeMode,
+    scope_actor_ids: list[str] | None,
+    scope_department_ids: list[str] | None,
+) -> ReportFilter:
+    now = time.time()
+    days = {
+        "day": 1,
+        "month": 30,
+        "retained": store.retention_days,
+    }[range_name]
+    return ReportFilter(
+        from_timestamp=now - days * 24 * 60 * 60,
+        to_timestamp=now,
+        selected_actor_id=actor_id,
+        scope_restricted=scope_mode != "all",
+        actor_ids=tuple(dict.fromkeys(scope_actor_ids or ())),
+        department_ids=tuple(dict.fromkeys(scope_department_ids or ())),
+    )