Refactor digitador bot and add runtime monitoring

services/extraction/api/main.py

@@ -228,6 +228,28 @@ def serialize_task(task: Task) -> dict[str, Any]:
 
 
 def persist_extraction_request(request: ExtractionRequest) -> dict[str, Any]:
+  from domain.usage_tracking import record_api_usage
+
+  usage_result: dict[str, Any] = {}
+
+  def capture_usage(
+    phase: str,
+    radicado: str,
+    usage: dict[str, Any] | None,
+    _cost: dict[str, Any] | None,
+  ) -> None:
+    nonlocal usage_result
+    model = request.model or settings.api.extractor_model
+    if phase == "normalize":
+      model = settings.api.normalizer_model
+    usage_result = record_api_usage(
+      usage_result,
+      phase=phase,
+      model=str(model),
+      usage=usage,
+      radicado=radicado,
+    )
+
   with session_scope() as session:
     batch = ExtractionBatch(
       status="running",
@@ -252,6 +274,7 @@ def persist_extraction_request(request: ExtractionRequest) -> dict[str, Any]:
       structure_mode=request.structure_mode,
       retry_on_empty=request.retry_on_empty,
       radicado_filter=request.radicado_filter,
+      on_usage=capture_usage,
     )
 
     with session_scope() as session:
@@ -279,6 +302,7 @@ def persist_extraction_request(request: ExtractionRequest) -> dict[str, Any]:
       session.flush()
       serialized = serialize_batch(batch)
       serialized["row_count"] = row_index
+      serialized["api_usage"] = usage_result.get("api_usage", {})
       return serialized
   except Exception as exc:
     with session_scope() as session:
@@ -312,6 +336,7 @@ def run_extraction_task(task_id: str) -> None:
         "extraction_batch_id": batch["id"],
         "row_count": batch.get("row_count", 0),
         "batch": batch,
+        "api_usage": batch.get("api_usage", {}),
       }
       task.error = None
       task.finished_at = utcnow()
@@ -620,6 +645,8 @@ async def _process_sync(
   from domain.profiles import get_profile
   from domain.prompts import PromptBuilder
   from domain.normalizer import normalize_to_schema
+  from domain.config import settings as _settings
+  from domain.usage_tracking import record_api_usage
 
   _log = _logging.getLogger("extraction.ingest")
 
@@ -656,13 +683,13 @@ async def _process_sync(
       tiff_range = req.get("tiff_page_range")
       model_name = getattr(svc.extractor, "model", "?")
       _log.info("→ OpenAI [%s] radicado=%s filename=%s", model_name, radicado, effective_name)
-      data, _usage = svc.extract_full_from_pdf(
+      data, extraction_usage = svc.extract_full_from_pdf(
         temp_path,
         instruction=prompt,
         tiff_page_range=tiff_range,
       )
-      tok_in = (_usage or {}).get("prompt_tokens", "?")
-      tok_out = (_usage or {}).get("completion_tokens", "?")
+      tok_in = (extraction_usage or {}).get("prompt_tokens", "?")
+      tok_out = (extraction_usage or {}).get("completion_tokens", "?")
       _log.info("← OpenAI [%s] radicado=%s tokens=%s→%s", model_name, radicado, tok_in, tok_out)
       if isinstance(data, dict):
         data["radicado"] = radicado
@@ -670,11 +697,13 @@ async def _process_sync(
         data = {"radicado": radicado, "data": data}
       norm = normalize_to_schema(data, paths=selected_paths, profile_name=prof.get("name", "invoice"))
       normalized_obj = data
+      normalizer_usage = None
       if isinstance(norm, dict):
         normalized_obj = norm.get("normalized") or data
-      return normalized_obj, selected_paths
+        normalizer_usage = norm.get("_usage")
+      return normalized_obj, selected_paths, extraction_usage, normalizer_usage, model_name
 
-    normalized_obj, selected_paths = await _asyncio.to_thread(_call_llm)
+    normalized_obj, selected_paths, extraction_usage, normalizer_usage, model_name = await _asyncio.to_thread(_call_llm)
 
     # ── Fase 2: persistir resultado (con FOR UPDATE para serializar) ───
     def _persist():
@@ -682,6 +711,14 @@ async def _process_sync(
         task = session.get(Task, task_id, with_for_update=True)
         if task is None:
           return {"error": "task_not_found"}
+        task.result = record_api_usage(
+          dict(task.result or {}), phase="extract", model=str(model_name),
+          usage=extraction_usage, radicado=radicado, filename=effective_name,
+        )
+        task.result = record_api_usage(
+          dict(task.result or {}), phase="normalize", model=str(_settings.api.normalizer_model),
+          usage=normalizer_usage, radicado=radicado, filename=effective_name,
+        )
         payload = persist_desktop_ingest_result(
           session,
           task=task,