agentloop-profiler 0.4.0__tar.gz → 0.5.0__tar.gz

{agentloop_profiler-0.4.0/agentloop_profiler.egg-info → agentloop_profiler-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentloop-profiler
-Version: 0.4.0
+Version: 0.5.0
 Summary: Profiler and optimization layer for AI agent execution graphs
 Author: Dipesh Babu
 License-Expression: Apache-2.0
@@ -49,7 +49,7 @@ Dynamic: license-file
 # AgentLoop
 
 [![CI](https://github.com/dipeshbabu/agentloop/actions/workflows/ci.yml/badge.svg)](https://github.com/dipeshbabu/agentloop/actions/workflows/ci.yml)
-[![PyPI](https://img.shields.io/pypi/v/agentloop-profiler.svg)](https://pypi.org/project/agentloop-profiler/)
+[![PyPI](https://img.shields.io/pypi/v/agentloop-profiler.svg?cacheSeconds=300)](https://pypi.org/project/agentloop-profiler/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-3776AB.svg)](https://www.python.org/downloads/)
 [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 

{agentloop_profiler-0.4.0 → agentloop_profiler-0.5.0}/README.md

@@ -1,7 +1,7 @@
 # AgentLoop
 
 [![CI](https://github.com/dipeshbabu/agentloop/actions/workflows/ci.yml/badge.svg)](https://github.com/dipeshbabu/agentloop/actions/workflows/ci.yml)
-[![PyPI](https://img.shields.io/pypi/v/agentloop-profiler.svg)](https://pypi.org/project/agentloop-profiler/)
+[![PyPI](https://img.shields.io/pypi/v/agentloop-profiler.svg?cacheSeconds=300)](https://pypi.org/project/agentloop-profiler/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-3776AB.svg)](https://www.python.org/downloads/)
 [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 

{agentloop_profiler-0.4.0 → agentloop_profiler-0.5.0}/agentloop/cli.py

@@ -27,7 +27,12 @@ from agentloop.quality import (
     quality_report_to_markdown,
 )
 from agentloop.replay import ReplayGates, build_replay_report, replay_report_to_markdown
-from agentloop.store import get_store
+from agentloop.store import (
+    DEFAULT_PAGE_SIZE,
+    FindingNotFoundError,
+    FindingTransitionError,
+    get_store,
+)
 from agentloop.tracer import AgentTrace
 from agentloop.value import build_value_report
 
@@ -581,9 +586,23 @@ def store_trace(
 
 
 @app.command("list-stored-traces")
-def list_stored_traces(project_id: str | None = None) -> None:
+def list_stored_traces(
+    project_id: str | None = None,
+    limit: int | None = typer.Option(None, help="Page size; omit to list every stored trace."),
+    cursor: str | None = typer.Option(
+        None, help="Continuation cursor from a previous --limit call's printed next-cursor."
+    ),
+) -> None:
     db = get_store()
-    traces = db.list_traces(project_id=project_id)
+    if limit is None and cursor is None:
+        traces = db.list_traces(project_id=project_id)
+        next_cursor = None
+    else:
+        page = db.list_traces_page(
+            project_id=project_id, limit=limit or DEFAULT_PAGE_SIZE, cursor=cursor
+        )
+        traces = page["items"]
+        next_cursor = page["next_cursor"]
     table = Table(title="Stored AgentLoop Traces")
     table.add_column("Project")
     table.add_column("Run ID")
@@ -599,12 +618,29 @@ def list_stored_traces(project_id: str | None = None) -> None:
             f"${float(item.get('estimated_cost_usd', 0)):.4f}",
         )
     console.print(table)
+    if next_cursor:
+        console.print(f"More results available. Next cursor: {next_cursor}")
 
 
 @app.command("list-findings")
-def list_findings(project_id: str | None = None, status: str | None = None) -> None:
+def list_findings(
+    project_id: str | None = None,
+    status: str | None = None,
+    limit: int | None = typer.Option(None, help="Page size; omit to list every matching finding."),
+    cursor: str | None = typer.Option(
+        None, help="Continuation cursor from a previous --limit call's printed next-cursor."
+    ),
+) -> None:
     db = get_store()
-    findings = db.list_findings(project_id=project_id, status=status)
+    if limit is None and cursor is None:
+        findings = db.list_findings(project_id=project_id, status=status)
+        next_cursor = None
+    else:
+        page = db.list_findings_page(
+            project_id=project_id, status=status, limit=limit or DEFAULT_PAGE_SIZE, cursor=cursor
+        )
+        findings = page["items"]
+        next_cursor = page["next_cursor"]
     table = Table(title="AgentLoop Findings")
     table.add_column("Severity")
     table.add_column("Type")
@@ -624,6 +660,41 @@ def list_findings(project_id: str | None = None, status: str | None = None) -> N
             f"{finding['estimated_latency_savings_ms'] / 1000:.2f}s / ${finding['estimated_cost_savings_usd']:.4f}",
         )
     console.print(table)
+    if next_cursor:
+        console.print(f"More results available. Next cursor: {next_cursor}")
+
+
+@app.command("update-finding-status")
+def update_finding_status_command(
+    run_id: str,
+    finding_id: str,
+    status: str,
+    project_id: str = "default",
+) -> None:
+    """Transition a stored finding's lifecycle status (detected/accepted/resolved/dismissed)."""
+    db = get_store()
+    try:
+        updated = db.update_finding_status(project_id, run_id, finding_id, status)
+    except FindingNotFoundError as exc:
+        raise typer.BadParameter(str(exc), param_hint="finding_id") from exc
+    except (FindingTransitionError, ValueError) as exc:
+        raise typer.BadParameter(str(exc), param_hint="status") from exc
+    console.print(f"Finding {finding_id} is now [bold]{updated['status']}[/bold]")
+
+
+@app.command("remote-update-finding-status")
+def remote_update_finding_status(
+    run_id: str,
+    finding_id: str,
+    status: str,
+    api_url: str = typer.Option("http://127.0.0.1:8000", help="AgentLoop API base URL."),
+    api_key: str | None = typer.Option(
+        None, help="Optional API key. Defaults to AGENTLOOP_API_KEY."
+    ),
+) -> None:
+    client = _remote_client(api_url, api_key)
+    updated = client.update_finding_status(run_id, finding_id, status)
+    console.print_json(data=updated)
 
 
 @app.command("optimization-queue")

{agentloop_profiler-0.4.0 → agentloop_profiler-0.5.0}/agentloop/client.py

@@ -49,10 +49,23 @@ class AgentLoopClient:
             payload = json.loads(Path(trace).read_text(encoding="utf-8"))
         return self._request("POST", "/traces", payload)
 
-    def list_traces(self, project_id: str | None = None) -> dict[str, Any]:
-        route = "/traces"
+    def list_traces(
+        self,
+        project_id: str | None = None,
+        *,
+        page_size: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {}
         if project_id:
-            route += "?" + urllib.parse.urlencode({"project_id": project_id})
+            params["project_id"] = project_id
+        if page_size is not None:
+            params["page_size"] = page_size
+        if cursor:
+            params["cursor"] = cursor
+        route = "/traces"
+        if params:
+            route += "?" + urllib.parse.urlencode(params)
         return self._request("GET", route)
 
     def usage_summary(self, project_id: str | None = None) -> dict[str, Any]:
@@ -74,18 +87,34 @@ class AgentLoopClient:
         return self._request("GET", f"/traces/{encoded_run_id}/diagnose")
 
     def list_findings(
-        self, project_id: str | None = None, status: str | None = None
+        self,
+        project_id: str | None = None,
+        status: str | None = None,
+        *,
+        page_size: int | None = None,
+        cursor: str | None = None,
     ) -> dict[str, Any]:
         params: dict[str, Any] = {}
         if project_id:
             params["project_id"] = project_id
         if status:
             params["status"] = status
+        if page_size is not None:
+            params["page_size"] = page_size
+        if cursor:
+            params["cursor"] = cursor
         route = "/findings"
         if params:
             route += "?" + urllib.parse.urlencode(params)
         return self._request("GET", route)
 
+    def update_finding_status(self, run_id: str, finding_id: str, status: str) -> dict[str, Any]:
+        encoded_run_id = urllib.parse.quote(run_id, safe="")
+        encoded_finding_id = urllib.parse.quote(finding_id, safe="")
+        return self._request(
+            "POST", f"/findings/{encoded_run_id}/{encoded_finding_id}/status", {"status": status}
+        )
+
     def optimization_queue(self, project_id: str | None = None) -> dict[str, Any]:
         route = "/optimization-queue"
         if project_id:

agentloop_profiler-0.5.0/agentloop/migrations.py

@@ -0,0 +1,241 @@
+"""Versioned schema migrations shared by :mod:`agentloop.store`'s two backends.
+
+Each :class:`Migration` carries dialect-specific, idempotent SQL statements.
+Idempotency (``IF NOT EXISTS`` / ``ON CONFLICT ... DO NOTHING``) lets concurrent
+``init()`` calls apply the same pending migration twice without corrupting state
+or racing on `schema_migrations` bookkeeping, which stands in for a real
+distributed lock that neither backend otherwise provides here.
+
+A fresh install and an existing pre-migration database both start with no rows
+in `schema_migrations`; migration 0001 reproduces the exact schema `init()`
+used to create inline, so both converge on the same structure.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+class MigrationError(RuntimeError):
+    """Raised when a migration statement fails to apply."""
+
+
+@dataclass(frozen=True)
+class Migration:
+    version: int
+    name: str
+    sqlite_statements: tuple[str, ...]
+    postgres_statements: tuple[str, ...]
+
+
+_BASELINE_SQLITE = (
+    """
+    CREATE TABLE IF NOT EXISTS projects (
+        project_id TEXT PRIMARY KEY,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )
+    """,
+    """
+    CREATE TABLE IF NOT EXISTS api_keys (
+        key_hash TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        prefix TEXT NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        last_used_at TEXT,
+        FOREIGN KEY(project_id) REFERENCES projects(project_id)
+    )
+    """,
+    """
+    CREATE TABLE IF NOT EXISTS traces (
+        run_id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        started_at TEXT,
+        payload_json TEXT NOT NULL,
+        total_runtime_ms REAL DEFAULT 0,
+        estimated_cost_usd REAL DEFAULT 0,
+        model_call_count INTEGER DEFAULT 0,
+        tool_call_count INTEGER DEFAULT 0,
+        retry_count INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY(project_id) REFERENCES projects(project_id)
+    )
+    """,
+    """
+    CREATE TABLE IF NOT EXISTS usage_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        total_runtime_ms REAL DEFAULT 0,
+        estimated_cost_usd REAL DEFAULT 0,
+        input_tokens INTEGER DEFAULT 0,
+        output_tokens INTEGER DEFAULT 0,
+        model_call_count INTEGER DEFAULT 0,
+        tool_call_count INTEGER DEFAULT 0,
+        retry_count INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )
+    """,
+    """
+    CREATE TABLE IF NOT EXISTS trace_findings (
+        project_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        finding_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        severity TEXT NOT NULL,
+        title TEXT NOT NULL,
+        confidence TEXT NOT NULL,
+        patchable INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'detected',
+        estimated_latency_savings_ms REAL DEFAULT 0,
+        estimated_cost_savings_usd REAL DEFAULT 0,
+        payload_json TEXT NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY(project_id, run_id, finding_id),
+        FOREIGN KEY(project_id) REFERENCES projects(project_id),
+        FOREIGN KEY(run_id) REFERENCES traces(run_id)
+    )
+    """,
+    "INSERT OR IGNORE INTO projects(project_id) VALUES ('default')",
+)
+
+_BASELINE_POSTGRES = (
+    "CREATE TABLE IF NOT EXISTS projects ("
+    "project_id TEXT PRIMARY KEY, created_at TIMESTAMPTZ DEFAULT now())",
+    "CREATE TABLE IF NOT EXISTS api_keys ("
+    "key_hash TEXT PRIMARY KEY, project_id TEXT NOT NULL REFERENCES projects(project_id), "
+    "name TEXT NOT NULL, prefix TEXT NOT NULL, created_at TIMESTAMPTZ DEFAULT now(), "
+    "last_used_at TIMESTAMPTZ)",
+    "CREATE TABLE IF NOT EXISTS traces ("
+    "run_id TEXT PRIMARY KEY, project_id TEXT NOT NULL REFERENCES projects(project_id), "
+    "name TEXT NOT NULL, started_at TEXT, payload_json JSONB NOT NULL, "
+    "total_runtime_ms DOUBLE PRECISION DEFAULT 0, estimated_cost_usd DOUBLE PRECISION DEFAULT 0, "
+    "model_call_count INTEGER DEFAULT 0, tool_call_count INTEGER DEFAULT 0, "
+    "retry_count INTEGER DEFAULT 0, created_at TIMESTAMPTZ DEFAULT now())",
+    "CREATE TABLE IF NOT EXISTS usage_events ("
+    "id BIGSERIAL PRIMARY KEY, project_id TEXT NOT NULL, run_id TEXT NOT NULL, "
+    "total_runtime_ms DOUBLE PRECISION DEFAULT 0, estimated_cost_usd DOUBLE PRECISION DEFAULT 0, "
+    "input_tokens INTEGER DEFAULT 0, output_tokens INTEGER DEFAULT 0, "
+    "model_call_count INTEGER DEFAULT 0, tool_call_count INTEGER DEFAULT 0, "
+    "retry_count INTEGER DEFAULT 0, created_at TIMESTAMPTZ DEFAULT now())",
+    "CREATE TABLE IF NOT EXISTS trace_findings ("
+    "project_id TEXT NOT NULL REFERENCES projects(project_id), "
+    "run_id TEXT NOT NULL REFERENCES traces(run_id), finding_id TEXT NOT NULL, "
+    "type TEXT NOT NULL, severity TEXT NOT NULL, title TEXT NOT NULL, confidence TEXT NOT NULL, "
+    "patchable BOOLEAN DEFAULT false, status TEXT DEFAULT 'detected', "
+    "estimated_latency_savings_ms DOUBLE PRECISION DEFAULT 0, "
+    "estimated_cost_savings_usd DOUBLE PRECISION DEFAULT 0, payload_json JSONB NOT NULL, "
+    "created_at TIMESTAMPTZ DEFAULT now(), updated_at TIMESTAMPTZ DEFAULT now(), "
+    "PRIMARY KEY(project_id, run_id, finding_id))",
+    "INSERT INTO projects(project_id) VALUES ('default') ON CONFLICT DO NOTHING",
+)
+
+# usage_events had no uniqueness constraint, so retried save_trace() calls appended
+# a new row per retry instead of updating one. De-duplicate existing data (keep the
+# most recent row per project/run) before the constraint can be added, or the
+# index creation fails on any store that already has duplicates.
+_DEDUPE_AND_CONSTRAIN_USAGE_EVENTS = (
+    "DELETE FROM usage_events WHERE id NOT IN "
+    "(SELECT MAX(id) FROM usage_events GROUP BY project_id, run_id)",
+    "CREATE UNIQUE INDEX IF NOT EXISTS ux_usage_events_project_run "
+    "ON usage_events(project_id, run_id)",
+)
+
+_PAGINATION_INDEXES = (
+    "CREATE INDEX IF NOT EXISTS ix_traces_project_created "
+    "ON traces(project_id, created_at, run_id)",
+    "CREATE INDEX IF NOT EXISTS ix_trace_findings_project_status_updated "
+    "ON trace_findings(project_id, status, updated_at, run_id, finding_id)",
+)
+
+MIGRATIONS: tuple[Migration, ...] = (
+    Migration(
+        version=1,
+        name="baseline",
+        sqlite_statements=_BASELINE_SQLITE,
+        postgres_statements=_BASELINE_POSTGRES,
+    ),
+    Migration(
+        version=2,
+        name="idempotent_usage_events",
+        sqlite_statements=_DEDUPE_AND_CONSTRAIN_USAGE_EVENTS,
+        postgres_statements=_DEDUPE_AND_CONSTRAIN_USAGE_EVENTS,
+    ),
+    Migration(
+        version=3,
+        name="pagination_indexes",
+        sqlite_statements=_PAGINATION_INDEXES,
+        postgres_statements=_PAGINATION_INDEXES,
+    ),
+)
+
+
+def _ensure_migrations_table_sqlite(conn) -> None:
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS schema_migrations (
+            version INTEGER PRIMARY KEY,
+            name TEXT NOT NULL,
+            applied_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+
+
+def _ensure_migrations_table_postgres(conn) -> None:
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS schema_migrations ("
+        "version INTEGER PRIMARY KEY, name TEXT NOT NULL, "
+        "applied_at TIMESTAMPTZ DEFAULT now())"
+    )
+
+
+def apply_sqlite_migrations(conn) -> None:
+    """Apply pending migrations to a SQLite connection inside its open transaction."""
+    import sqlite3
+
+    _ensure_migrations_table_sqlite(conn)
+    applied = {row[0] for row in conn.execute("SELECT version FROM schema_migrations").fetchall()}
+    for migration in MIGRATIONS:
+        if migration.version in applied:
+            continue
+        try:
+            for statement in migration.sqlite_statements:
+                conn.execute(statement)
+            conn.execute(
+                "INSERT OR IGNORE INTO schema_migrations(version, name) VALUES (?, ?)",
+                (migration.version, migration.name),
+            )
+        except sqlite3.Error as exc:
+            raise MigrationError(
+                f"migration {migration.version} ({migration.name}) failed: {exc}. "
+                "The transaction was rolled back; the store is unchanged. Fix the "
+                "underlying issue (e.g. free disk space, resolve a lock) and retry."
+            ) from exc
+
+
+def apply_postgres_migrations(conn) -> None:
+    """Apply pending migrations to a psycopg connection inside its open transaction."""
+    import psycopg
+
+    _ensure_migrations_table_postgres(conn)
+    applied = {row[0] for row in conn.execute("SELECT version FROM schema_migrations").fetchall()}
+    for migration in MIGRATIONS:
+        if migration.version in applied:
+            continue
+        try:
+            for statement in migration.postgres_statements:
+                conn.execute(statement)
+            conn.execute(
+                "INSERT INTO schema_migrations(version, name) VALUES (%s, %s) "
+                "ON CONFLICT (version) DO NOTHING",
+                (migration.version, migration.name),
+            )
+        except psycopg.Error as exc:
+            raise MigrationError(
+                f"migration {migration.version} ({migration.name}) failed: {exc}. "
+                "The transaction was rolled back; the store is unchanged. Fix the "
+                "underlying issue (e.g. permissions, a blocking lock) and retry."
+            ) from exc

{agentloop_profiler-0.4.0 → agentloop_profiler-0.5.0}/agentloop/server.py

@@ -12,7 +12,16 @@ from agentloop.findings import build_diagnosis
 from agentloop.issues import build_issue_drafts
 from agentloop.optimizer import build_optimization_plan
 from agentloop.quality import build_quality_report
-from agentloop.store import TraceProjectConflictError, TraceStore, get_store
+from agentloop.store import (
+    DEFAULT_PAGE_SIZE,
+    MAX_PAGE_SIZE,
+    FindingNotFoundError,
+    FindingTransitionError,
+    InvalidCursorError,
+    TraceProjectConflictError,
+    TraceStore,
+    get_store,
+)
 from agentloop.tracer import AgentTrace
 from agentloop.value import build_value_report
 from agentloop.version import __version__
@@ -140,11 +149,36 @@ def _selected_project(project_id_filter: str | None, authenticated_project: str)
 @app.get("/traces")
 def list_traces(
     project_id_filter: str | None = Query(default=None, alias="project_id"),
+    page_size: int | None = Query(default=None, ge=1, le=MAX_PAGE_SIZE),
+    cursor: str | None = Query(default=None),
     project_id: str = Depends(resolve_project),
     db: TraceStore = Depends(store),
 ) -> dict[str, Any]:
+    """List traces for a project.
+
+    Without `page_size`/`cursor`, returns the full (bounded) list for
+    backward compatibility. Pass `page_size` to opt into keyset pagination:
+    the response then includes `next_cursor` — pass it back as `cursor` to
+    fetch the next page; `next_cursor: null` means there are no more rows.
+    """
     selected_project = _selected_project(project_id_filter, project_id)
-    return {"project_id": selected_project, "traces": db.list_traces(project_id=selected_project)}
+    if page_size is None and cursor is None:
+        return {
+            "project_id": selected_project,
+            "traces": db.list_traces(project_id=selected_project),
+            "next_cursor": None,
+        }
+    try:
+        page = db.list_traces_page(
+            project_id=selected_project, limit=page_size or DEFAULT_PAGE_SIZE, cursor=cursor
+        )
+    except InvalidCursorError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from None
+    return {
+        "project_id": selected_project,
+        "traces": page["items"],
+        "next_cursor": page["next_cursor"],
+    }
 
 
 def _load_trace_or_404(db: TraceStore, run_id: str, project_id: str) -> AgentTrace:
@@ -187,16 +221,61 @@ def diagnose_trace(
 def list_findings(
     status: str | None = Query(default=None),
     project_id_filter: str | None = Query(default=None, alias="project_id"),
+    page_size: int | None = Query(default=None, ge=1, le=MAX_PAGE_SIZE),
+    cursor: str | None = Query(default=None),
     project_id: str = Depends(resolve_project),
     db: TraceStore = Depends(store),
 ) -> dict[str, Any]:
+    """List findings for a project. See `list_traces` for the pagination contract.
+
+    Paginated results are ordered by recency (most recently updated first),
+    not by the priority order `optimization-queue` uses.
+    """
     selected_project = _selected_project(project_id_filter, project_id)
+    if page_size is None and cursor is None:
+        return {
+            "project_id": selected_project,
+            "findings": db.list_findings(project_id=selected_project, status=status),
+            "next_cursor": None,
+        }
+    try:
+        page = db.list_findings_page(
+            project_id=selected_project,
+            status=status,
+            limit=page_size or DEFAULT_PAGE_SIZE,
+            cursor=cursor,
+        )
+    except InvalidCursorError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from None
     return {
         "project_id": selected_project,
-        "findings": db.list_findings(project_id=selected_project, status=status),
+        "findings": page["items"],
+        "next_cursor": page["next_cursor"],
     }
 
 
+class FindingStatusPayload(BaseModel):
+    status: str
+
+
+@app.post("/findings/{run_id}/{finding_id}/status")
+def update_finding_status(
+    run_id: str,
+    finding_id: str,
+    payload: FindingStatusPayload,
+    project_id: str = Depends(resolve_project),
+    db: TraceStore = Depends(store),
+) -> dict[str, Any]:
+    try:
+        return db.update_finding_status(project_id, run_id, finding_id, payload.status)
+    except FindingNotFoundError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from None
+    except FindingTransitionError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from None
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from None
+
+
 @app.get("/optimization-queue")
 def optimization_queue(
     project_id_filter: str | None = Query(default=None, alias="project_id"),