create-windy 0.8.3 → 0.9.1

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

@@ -1,149 +0,0 @@
-from __future__ import annotations
-
-from collections import defaultdict
-from threading import Lock
-
-from .report_types import AttemptTerminalOutcome, UsageFacts
-
-
-class AgentRuntimeMetrics:
-    """In-process Prometheus counters with deliberately low-cardinality labels."""
-
-    def __init__(self) -> None:
-        self._values: defaultdict[tuple[str, ...], int] = defaultdict(int)
-        self._lock = Lock()
-
-    def observe_run(self, outcome: str) -> None:
-        with self._lock:
-            self._values[("runs", outcome)] += 1
-
-    def observe_reporting_failure(self, stage: str) -> None:
-        with self._lock:
-            self._values[("reporting_failures", stage)] += 1
-
-    def observe_attempt(
-        self,
-        outcome: AttemptTerminalOutcome,
-        usage: UsageFacts,
-    ) -> None:
-        with self._lock:
-            self._values[("attempts", outcome)] += 1
-            self._values[("cache", usage.cache_status)] += 1
-            self._values[("usage", usage.source)] += 1
-            for kind, value in (
-                ("input", usage.input_tokens),
-                ("output", usage.output_tokens),
-                ("cached_input", usage.cached_input_tokens),
-                ("reasoning", usage.reasoning_tokens),
-                ("total", usage.total_tokens),
-            ):
-                if value is not None:
-                    self._values[("tokens", kind, usage.source)] += value
-
-    def render(self) -> str:
-        with self._lock:
-            values = dict(self._values)
-        lines = [
-            "# HELP southwind_agent_runtime_runs_total Terminal Agent runs.",
-            "# TYPE southwind_agent_runtime_runs_total counter",
-        ]
-        lines.extend(
-            metric(
-                "southwind_agent_runtime_runs_total",
-                {"outcome": outcome},
-                values.get(("runs", outcome), 0),
-            )
-            for outcome in ("completed", "failed", "cancelled")
-        )
-        lines.extend(
-            (
-                "# HELP southwind_agent_runtime_attempts_total Provider attempts.",
-                "# TYPE southwind_agent_runtime_attempts_total counter",
-            )
-        )
-        lines.extend(
-            metric(
-                "southwind_agent_runtime_attempts_total",
-                {"outcome": outcome},
-                values.get(("attempts", outcome), 0),
-            )
-            for outcome in (
-                "completed",
-                "failed",
-                "cancelled",
-                "blocked",
-                "abandoned",
-            )
-        )
-        lines.extend(
-            (
-                "# HELP southwind_agent_runtime_cache_attempts_total Cache facts.",
-                "# TYPE southwind_agent_runtime_cache_attempts_total counter",
-            )
-        )
-        lines.extend(
-            metric(
-                "southwind_agent_runtime_cache_attempts_total",
-                {"status": status},
-                values.get(("cache", status), 0),
-            )
-            for status in ("hit", "miss", "unknown")
-        )
-        lines.extend(
-            (
-                "# HELP southwind_agent_runtime_usage_attempts_total Usage coverage.",
-                "# TYPE southwind_agent_runtime_usage_attempts_total counter",
-            )
-        )
-        lines.extend(
-            metric(
-                "southwind_agent_runtime_usage_attempts_total",
-                {"source": source},
-                values.get(("usage", source), 0),
-            )
-            for source in ("provider-reported", "estimated", "unknown")
-        )
-        lines.extend(
-            (
-                "# HELP southwind_agent_runtime_reporting_failures_total "
-                "Internal reporting write failures.",
-                "# TYPE southwind_agent_runtime_reporting_failures_total counter",
-            )
-        )
-        lines.extend(
-            metric(
-                "southwind_agent_runtime_reporting_failures_total",
-                {"stage": stage},
-                values.get(("reporting_failures", stage), 0),
-            )
-            for stage in (
-                "run_ensure",
-                "run_start",
-                "run_status",
-                "run_terminal",
-                "attempt_start",
-                "attempt_terminal",
-            )
-        )
-        lines.extend(
-            (
-                "# HELP southwind_agent_runtime_tokens_total Reported token usage.",
-                "# TYPE southwind_agent_runtime_tokens_total counter",
-            )
-        )
-        for key, value in sorted(values.items()):
-            if len(key) == 3 and key[0] == "tokens":
-                _, kind, source = key
-                lines.append(
-                    metric(
-                        "southwind_agent_runtime_tokens_total",
-                        {"kind": kind, "source": source},
-                        value,
-                    )
-                )
-        return "\n".join(lines) + "\n"
-
-
-def metric(name: str, labels: dict[str, str], value: int) -> str:
-    encoded = ",".join(f'{key}="{item}"' for key, item in labels.items())
-    return f"{name}{{{encoded}}} {value}"

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

@@ -1,300 +0,0 @@
-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,
-        "engineId": run.engine_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),
-        "modelDeployments": model_deployments(attempts),
-        "models": models,
-        "cacheStatus": cache,
-        "usage": usage_value(attempts),
-    }
-
-
-def model_deployments(attempts: Iterable[AttemptReport]) -> list[dict[str, object]]:
-    """按首次 Attempt 顺序保留真实的模型/deployment 组合及出现次数。"""
-    groups: dict[tuple[str, str], int] = {}
-    for item in attempts:
-        key = (item.deployment_key, item.reported_model or item.requested_model)
-        groups[key] = groups.get(key, 0) + 1
-    return [
-        {
-            "deploymentKey": deployment_key,
-            "model": model,
-            "attemptCount": attempt_count,
-        }
-        for (deployment_key, model), attempt_count in groups.items()
-    ]
-
-
-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,
-        "requestedModel": item.requested_model,
-        "reportedModel": item.reported_model,
-        "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

@@ -1,132 +0,0 @@
-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
-from .store import RunStore
-from .trajectory import project_run_trajectory
-
-type ReportRange = Literal["day", "month", "retained"]
-type ScopeMode = Literal["all", "bounded", "none"]
-
-
-def create_report_router(
-    store: AgentRuntimeReportStore,
-    run_store: RunStore,
-    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,
-            "trajectory": project_run_trajectory(await run_store.get(run_id)),
-        }
-
-    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 ())),
-    )