tegwick
d65bc701da
Introduces end-to-end token consumption tracking so agent work is visible as a cost/effort metric alongside tasks and workplans. - Migration o2j3k4l5m6n7: token_events table with FK indexes on task_id, workstream_id, repo_id, created_at - ORM model, Pydantic schemas (TokenEventCreate, TokenEventRead with computed tokens_total, TokenSummary) - Router: POST /token-events/, GET /token-events/ (7 filters), GET /token-events/summary/ (task|workstream|repo|commit|release scope) - MCP tools: record_token_event, get_token_summary (formatted table) - update_task_status enriched with optional tokens_in/tokens_out passthrough — one call creates status update + token event - Dashboard token-cost.md page: by-repo bar, by-workplan table, by-model bar, top-10 tasks by tokens - ralph-workplan skill updated with token reporting guidance and per-task heuristics for estimating counts - Tests: test_token_events.py + test_token_passthrough.py (182 pass) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
118 lines
3.7 KiB
Python
118 lines
3.7 KiB
Python
import uuid
|
|
from datetime import date
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from api.database import get_session
|
|
from api.models.task import Task, TaskStatus
|
|
from api.models.token_event import TokenEvent
|
|
from api.schemas.task import TaskCreate, TaskRead, TaskUpdate
|
|
|
|
router = APIRouter(prefix="/tasks", tags=["tasks"])
|
|
|
|
|
|
@router.get("/", response_model=list[TaskRead])
|
|
async def list_tasks(
|
|
workstream_id: uuid.UUID | None = None,
|
|
status: TaskStatus | None = None,
|
|
assignee: str | None = None,
|
|
needs_human: bool | None = Query(None),
|
|
priority: str | None = None,
|
|
due_date_before: date | None = None,
|
|
session: AsyncSession = Depends(get_session),
|
|
) -> list[Task]:
|
|
q = select(Task)
|
|
if workstream_id:
|
|
q = q.where(Task.workstream_id == workstream_id)
|
|
if status:
|
|
q = q.where(Task.status == status)
|
|
if assignee:
|
|
q = q.where(Task.assignee == assignee)
|
|
if needs_human is not None:
|
|
q = q.where(Task.needs_human == needs_human)
|
|
if priority:
|
|
q = q.where(Task.priority == priority)
|
|
if due_date_before is not None:
|
|
q = q.where(Task.due_date <= due_date_before)
|
|
q = q.order_by(Task.created_at)
|
|
result = await session.execute(q)
|
|
return list(result.scalars().all())
|
|
|
|
|
|
@router.post("/", response_model=TaskRead, status_code=status.HTTP_201_CREATED)
|
|
async def create_task(
|
|
body: TaskCreate,
|
|
session: AsyncSession = Depends(get_session),
|
|
) -> Task:
|
|
task = Task(**body.model_dump())
|
|
session.add(task)
|
|
await session.commit()
|
|
await session.refresh(task)
|
|
return task
|
|
|
|
|
|
@router.get("/{task_id}", response_model=TaskRead)
|
|
async def get_task(
|
|
task_id: uuid.UUID,
|
|
session: AsyncSession = Depends(get_session),
|
|
) -> Task:
|
|
task = await session.get(Task, task_id)
|
|
if task is None:
|
|
raise HTTPException(status_code=404, detail="Task not found")
|
|
return task
|
|
|
|
|
|
@router.patch("/{task_id}", response_model=TaskRead)
|
|
async def update_task(
|
|
task_id: uuid.UUID,
|
|
body: TaskUpdate,
|
|
session: AsyncSession = Depends(get_session),
|
|
) -> Task:
|
|
task = await session.get(Task, task_id)
|
|
if task is None:
|
|
raise HTTPException(status_code=404, detail="Task not found")
|
|
|
|
# Separate token fields from task fields
|
|
token_fields = {"tokens_in", "tokens_out", "model", "agent", "session_id"}
|
|
update_data = body.model_dump(exclude_unset=True)
|
|
token_data = {k: update_data.pop(k) for k in list(update_data.keys()) if k in token_fields}
|
|
|
|
for field, value in update_data.items():
|
|
setattr(task, field, value)
|
|
await session.commit()
|
|
await session.refresh(task)
|
|
|
|
# Create token event if token passthrough fields provided
|
|
if "tokens_in" in token_data and "tokens_out" in token_data:
|
|
event = TokenEvent(
|
|
task_id=task_id,
|
|
workstream_id=task.workstream_id,
|
|
tokens_in=token_data["tokens_in"],
|
|
tokens_out=token_data["tokens_out"],
|
|
model=token_data.get("model"),
|
|
agent=token_data.get("agent"),
|
|
session_id=token_data.get("session_id"),
|
|
ref_type="task",
|
|
ref_id=str(task_id),
|
|
)
|
|
session.add(event)
|
|
await session.commit()
|
|
|
|
return task
|
|
|
|
|
|
@router.delete("/{task_id}", response_model=TaskRead)
|
|
async def cancel_task(
|
|
task_id: uuid.UUID,
|
|
session: AsyncSession = Depends(get_session),
|
|
) -> Task:
|
|
task = await session.get(Task, task_id)
|
|
if task is None:
|
|
raise HTTPException(status_code=404, detail="Task not found")
|
|
task.status = TaskStatus.cancelled
|
|
await session.commit()
|
|
await session.refresh(task)
|
|
return task
|