Merge branch 'ftr/sidebar-improvements' into development

Author: Siddharth-Khattar

backend/app/agents/domain_agent_runner.py

@@ -219,6 +219,7 @@ async def run(
         input_data: dict[str, object] = {
             "file_ids": file_ids,
             "file_count": len(files),
+            "file_names": [f.original_filename for f in files],
         }
         if stage_suffix:
             input_data["stage_suffix"] = stage_suffix

backend/app/api/agents.py

@@ -20,6 +20,7 @@
 from app.schemas.agent import (
     AnalysisMode,
     AnalysisStartRequest,
+    ExecutionDetailResponse,
     OrchestratorOutput,
     TriageOutput,
 )
@@ -412,3 +413,48 @@ async def get_analysis_status(
         error=error_msg,
         domain_results_summary=domain_summary,
     )
+
+
+# ---------------------------------------------------------------------------
+# Execution Detail Endpoint
+# ---------------------------------------------------------------------------
+
+
+@router.get(
+    "/api/agents/executions/{execution_id}",
+    response_model=ExecutionDetailResponse,
+    summary="Get detailed agent execution data",
+    responses={
+        401: {"model": ErrorResponse, "description": "Unauthorized"},
+        404: {"model": ErrorResponse, "description": "Execution not found"},
+    },
+)
+async def get_execution_detail(
+    execution_id: UUID,
+    current_user: CurrentUser,
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> ExecutionDetailResponse:
+    """Fetch full execution data (output_data, input_data, thinking_traces).
+
+    Verifies case ownership via the execution's case_id.
+    """
+    result = await db.execute(
+        select(AgentExecution).where(AgentExecution.id == execution_id)
+    )
+    execution = result.scalar_one_or_none()
+
+    if not execution:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Execution not found",
+        )
+
+    # Verify ownership via case
+    case = await _get_user_case(db, execution.case_id, current_user.id)
+    if not case:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Execution not found",
+        )
+
+    return ExecutionDetailResponse.model_validate(execution)

backend/app/schemas/agent.py

@@ -684,3 +684,22 @@ class AgentExecutionResponse(BaseModel):
     updated_at: datetime = Field(..., description="Record last update time")
 
     model_config = ConfigDict(from_attributes=True)
+
+
+class ExecutionDetailResponse(BaseModel):
+    """Detailed execution data for a single agent run."""
+
+    id: UUID = Field(..., description="Execution record ID")
+    agent_name: str = Field(..., description="Logical agent name")
+    model_name: str = Field(..., description="Gemini model ID")
+    input_data: dict[str, object] | None = Field(
+        default=None, description="Agent input context"
+    )
+    output_data: dict[str, object] | None = Field(
+        default=None, description="Structured agent output"
+    )
+    thinking_traces: list[dict[str, object]] | None = Field(
+        default=None, description="Thinking traces"
+    )
+
+    model_config = ConfigDict(from_attributes=True)

backend/app/services/agent_events.py

@@ -535,6 +535,7 @@ def build_execution_metadata(
         duration_ms = int(delta.total_seconds() * 1000)
 
     return {
+        "executionId": str(execution.id),
         "inputTokens": execution.input_tokens or 0,
         "outputTokens": execution.output_tokens or 0,
         "durationMs": duration_ms or 0,
@@ -622,6 +623,7 @@ def build_agent_result(
                     routing_decisions_camel.append(
                         {
                             "fileId": rd.get("file_id", ""),
+                            "fileName": rd.get("file_name", ""),
                             "targetAgent": agent,
                             "reason": rd.get("reasoning", ""),
                             "domainScore": score,
@@ -644,16 +646,21 @@ def build_agent_result(
         # Domain agents (financial, legal, evidence)
         findings = output.get("findings", [])
         entities = output.get("entities", [])
-        # Extract group label from input_data stage_suffix
+        # Extract group label and file names from input_data
         group_label = "default"
+        file_names: list[str] = []
         if execution.input_data and isinstance(execution.input_data, dict):
             raw_suffix = execution.input_data.get("stage_suffix", "")
             group_label = (
                 raw_suffix.lstrip("_") if isinstance(raw_suffix, str) else "default"
             ) or "default"
+            raw_names = execution.input_data.get("file_names", [])
+            if isinstance(raw_names, list):
+                file_names = [str(n) for n in raw_names]
 
         result["baseAgentType"] = agent_name
         result["groupLabel"] = group_label
+        result["fileNames"] = file_names
         result["outputs"] = [
             {
                 "type": f"{agent_name}-findings",

backend/app/services/pipeline.py

@@ -366,6 +366,7 @@ async def run_analysis_workflow(
                         "routingDecisions": [
                             {
                                 "fileId": rd.file_id,
+                                "fileName": rd.file_name or "",
                                 "targetAgent": agent,
                                 "reason": rd.reasoning,
                                 "domainScore": getattr(rd.domain_scores, agent, 0),
@@ -530,6 +531,12 @@ async def run_analysis_workflow(
                 ]
                 expected_tasks = compute_agent_tasks(orchestrator_output, files)
 
+                # Build lookup: compound_id -> list of original filenames
+                domain_file_names: dict[str, list[str]] = {}
+                for task in expected_tasks:
+                    cid = f"{task.agent_type}_{task.group_label}"
+                    domain_file_names[cid] = [f.original_filename for f in task.files]
+
                 # Emit agent-started for each expected (agent_type, group_label) pair
                 # Use compound identifier: "{agent_type}_{group_label}"
                 domain_task_ids: dict[str, str] = {}  # compound_id -> task_id
@@ -607,6 +614,7 @@ async def run_analysis_workflow(
                                     "agentType": compound_id,
                                     "baseAgentType": domain_agent,
                                     "groupLabel": grp_label,
+                                    "fileNames": domain_file_names.get(compound_id, []),
                                     "outputs": [
                                         {
                                             "type": f"{domain_agent}-findings",

backend/redact_pdf.py

@@ -79,7 +79,10 @@ def main():
         sys.exit(1)
 
     if not input_path.suffix.lower() == ".pdf":
-        print(f"Error: Input must be a PDF file: {args.pdf_file}", file=sys.stderr)
+        print(
+            f"Error: Input must be a PDF file: {args.pdf_file}",
+            file=sys.stderr,
+        )
         sys.exit(1)
 
     try:
@@ -98,7 +101,7 @@ def main():
             permanent=args.permanent,
         )
 
-        print(f"✓ Redaction complete!")
+        print("✓ Redaction complete!")
         print(f"  Output: {output_file}")
         print(f"  Redacted items: {info['redaction_count']}")
 

backend/test_redaction.py

@@ -24,7 +24,7 @@ def test_redaction():
     try:
         output_file, response = agent.redact_pdf(pdf_path, redaction_prompt)
 
-        print(f"✓ Success!")
+        print("✓ Success!")
         print(f"  Output: {output_file}")
         print(f"  Redacted: {len(response.targets)} items")
         print(f"  Reasoning: {response.reasoning}\n")

backend/test_video_redaction.py

@@ -67,7 +67,7 @@ def test_video_redaction():
     }
 
     print("\nSending request to API...")
-    print(f"⏳ Processing... (this may take 2-10 minutes)")
+    print("⏳ Processing... (this may take 2-10 minutes)")
     print(f"Started at: {datetime.now().strftime('%H:%M:%S')}")
     print()
 
@@ -122,7 +122,7 @@ def test_video_redaction():
         if result.get("logs"):
             log_path = f"{stem}_logs_{timestamp}.txt"
             with open(log_path, "w") as f:
-                f.write(f"Video Censorship Pipeline Logs\n")
+                f.write("Video Censorship Pipeline Logs\n")
                 f.write(f"Generated: {datetime.now().isoformat()}\n")
                 f.write(f"Video: {video_path}\n")
                 f.write(f"Prompt: {prompt}\n")
@@ -133,7 +133,7 @@ def test_video_redaction():
             print(f"📝 Logs saved: {log_path}")
 
             # Print last 20 logs
-            print(f"\n📋 Pipeline Logs (last 20 entries):")
+            print("\n📋 Pipeline Logs (last 20 entries):")
             for log in result["logs"][-20:]:
                 if "[ERROR]" in log:
                     print(f"  ❌ {log}")
@@ -143,7 +143,7 @@ def test_video_redaction():
                     print(f"  ℹ️  {log}")
 
     except requests.Timeout:
-        print(f"❌ Request timed out after 15 minutes")
+        print("❌ Request timed out after 15 minutes")
         print("   Video may be too long or complex")
     except requests.RequestException as e:
         print(f"❌ Request failed: {e}")