Implement unified story generation flow

backend/app/services/generation_jobs.py

@@ -11,7 +11,11 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.config import settings
 from app.core.logging import get_logger
-from app.db.models import GenerationJob, GenerationJobEvent, Story
+from app.db.models import (
+    GenerationJob,
+    GenerationJobEvent,
+    Story,
+)
 
 logger = get_logger(__name__)
 
@@ -712,87 +716,6 @@ async def get_user_provider_analytics(
     }
 
 
-async def get_admin_provider_analytics(
-    db: AsyncSession,
-    *,
-    days: int | None = None,
-    capability: str | None = None,
-) -> dict[str, Any]:
-    """Aggregate provider telemetry across every user in the current environment."""
-
-    rows = (await db.execute(_provider_events_query(days=days))).all()
-    events = [event for event, _, _ in rows]
-    filtered_rows = [
-        (event, user_id, story_id)
-        for event, user_id, story_id in rows
-        if _event_matches_capability(event, capability)
-    ]
-
-    by_user: dict[str, dict[str, Any]] = {}
-    filtered_job_ids = {event.job_id for event, _, _ in filtered_rows}
-    filtered_story_ids = {
-        story_id for _, _, story_id in filtered_rows if story_id is not None
-    }
-    filtered_user_ids = {user_id for _, user_id, _ in filtered_rows}
-
-    for event, user_id, story_id in filtered_rows:
-        bucket = by_user.setdefault(
-            user_id,
-            {
-                "user_id": user_id,
-                "call_count": 0,
-                "success_count": 0,
-                "failure_count": 0,
-                "estimated_cost_usd": 0.0,
-                "job_ids": set(),
-                "story_ids": set(),
-            },
-        )
-        bucket["call_count"] += 1
-        bucket["job_ids"].add(event.job_id)
-        if story_id is not None:
-            bucket["story_ids"].add(story_id)
-
-        if event.event_type == "provider_call_succeeded":
-            bucket["success_count"] += 1
-            bucket["estimated_cost_usd"] += (
-                _as_float((event.event_metadata or {}).get("estimated_cost_usd")) or 0.0
-            )
-        else:
-            bucket["failure_count"] += 1
-
-    serialized_users = [
-        {
-            "user_id": user_id,
-            "call_count": bucket["call_count"],
-            "success_count": bucket["success_count"],
-            "failure_count": bucket["failure_count"],
-            "job_count": len(bucket["job_ids"]),
-            "story_count": len(bucket["story_ids"]),
-            "estimated_cost_usd": round(bucket["estimated_cost_usd"], 6),
-        }
-        for user_id, bucket in by_user.items()
-    ]
-    serialized_users.sort(
-        key=lambda item: (
-            -int(item["call_count"]),
-            -float(item["estimated_cost_usd"]),
-            str(item["user_id"]),
-        )
-    )
-
-    return {
-        "scope": "current_environment",
-        "window_days": days,
-        "capability": capability,
-        **_aggregate_provider_events(events, capability=capability),
-        "user_count": len(filtered_user_ids),
-        "job_count": len(filtered_job_ids),
-        "story_count": len(filtered_story_ids),
-        "by_user": serialized_users,
-    }
-
-
 async def get_user_generation_ops_summary(
     db: AsyncSession,
     *,