flock-core 0.4.0b43__py3-none-any.whl → 0.4.0b45__py3-none-any.whl

flock/webapp/app/api/agent_management.py

@@ -1,55 +1,80 @@
+# src/flock/webapp/app/api/agent_management.py
+import json
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-from fastapi import APIRouter, Form, Request
+from fastapi import (  # Added Depends and HTTPException
+    APIRouter,
+    Depends,
+    Form,
+    Request,
+)
 from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+
+# Import the dependency to get the current Flock instance
+from flock.webapp.app.dependencies import (
+    get_flock_instance,
+    get_optional_flock_instance,
+)
+
+# Import service functions that now take app_state (or directly the Flock instance)
 from flock.webapp.app.services.flock_service import (
     add_agent_to_current_flock_service,
-    get_current_flock_instance,
-    get_registered_items_service,
+    get_registered_items_service,  # This is fine as it doesn't depend on current_flock
     remove_agent_from_current_flock_service,
     update_agent_in_current_flock_service,
 )
 
 router = APIRouter()
-BASE_DIR = Path(__file__).resolve().parent.parent.parent
+BASE_DIR = Path(__file__).resolve().parent.parent.parent # Points to flock-ui/
 templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
 
 
 @router.get("/htmx/agent-list", response_class=HTMLResponse)
 async def htmx_get_agent_list(
-    request: Request, message: str = None, success: bool = None
+    request: Request,
+    message: str = None,
+    success: bool = None,
+    # Use Depends to get the current flock instance.
+    # Use get_optional_flock_instance if the route should work even without a flock loaded.
+    current_flock: "Flock | None" = Depends(get_optional_flock_instance)
 ):
-    flock = get_current_flock_instance()
-    if not flock:
-        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
+    if not current_flock:
+        # If used in a context where flock might not be loaded (e.g. main agent manager view before load)
+        # it should be handled by the page template or a higher-level redirect.
+        # For a partial, returning an error or empty state is reasonable.
+        return HTMLResponse("<div id='agent-list-container'><p class='error'>No Flock loaded to display agents.</p></div>", headers={"HX-Retarget": "#agent-list-container", "HX-Reswap": "innerHTML"})
+
     return templates.TemplateResponse(
         "partials/_agent_list.html",
         {
             "request": request,
-            "flock": flock,
+            "flock": current_flock, # Pass the injected flock instance
             "message": message,
             "success": success,
         },
     )
 
 
-@router.get(
-    "/htmx/agents/{agent_name}/details-form", response_class=HTMLResponse
-)
-async def htmx_get_agent_details_form(request: Request, agent_name: str):
-    flock = get_current_flock_instance()
-    if not flock:
-        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
-    agent = flock.agents.get(agent_name)
+@router.get("/htmx/agents/{agent_name}/details-form", response_class=HTMLResponse)
+async def htmx_get_agent_details_form(
+    request: Request,
+    agent_name: str,
+    current_flock: "Flock" = Depends(get_flock_instance) # Expect flock to be loaded
+):
+    # flock instance is now injected by FastAPI
+    agent = current_flock.agents.get(agent_name)
     if not agent:
         return HTMLResponse(
-            f"<p class='error'>Agent '{agent_name}' not found.</p>"
+            f"<p class='error'>Agent '{agent_name}' not found in the current Flock.</p>"
         )
 
     registered_tools = get_registered_items_service("tool")
-    current_tools = (
+    current_agent_tools = (
         [tool.__name__ for tool in agent.tools] if agent.tools else []
     )
 
@@ -60,22 +85,23 @@ async def htmx_get_agent_details_form(request: Request, agent_name: str):
             "agent": agent,
             "is_new": False,
             "registered_tools": registered_tools,
-            "current_tools": current_tools,
+            "current_tools": current_agent_tools,
         },
     )
 
 
 @router.get("/htmx/agents/new-agent-form", response_class=HTMLResponse)
-async def htmx_get_new_agent_form(request: Request):
-    flock = get_current_flock_instance()
-    if not flock:
-        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
+async def htmx_get_new_agent_form(
+    request: Request,
+    current_flock: "Flock" = Depends(get_flock_instance) # Expect flock for context, even for new agent
+):
+    # current_flock is injected, primarily to ensure context if needed by template/tools list
     registered_tools = get_registered_items_service("tool")
     return templates.TemplateResponse(
         "partials/_agent_detail_form.html",
         {
             "request": request,
-            "agent": None,  # For new agent
+            "agent": None,
             "is_new": True,
             "registered_tools": registered_tools,
             "current_tools": [],
@@ -83,82 +109,54 @@ async def htmx_get_new_agent_form(request: Request):
     )
 
 
-@router.post(
-    "/htmx/agents", response_class=HTMLResponse
-)  # For creating new agent
+@router.post("/htmx/agents", response_class=HTMLResponse)
 async def htmx_create_agent(
     request: Request,
     agent_name: str = Form(...),
     agent_description: str = Form(""),
-    agent_model: str = Form(None),  # Can be empty to use Flock default
+    agent_model: str = Form(None),
     input_signature: str = Form(...),
     output_signature: str = Form(...),
     tools: list[str] = Form([]),
-):  # FastAPI handles list from multiple form fields with same name
-    flock = get_current_flock_instance()
-    if not flock:
-        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
-
-    if (
-        not agent_name.strip()
-        or not input_signature.strip()
-        or not output_signature.strip()
-    ):
-        # Render form again with error (or use a different target for error message)
+    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
+):
+    # The service function add_agent_to_current_flock_service now takes app_state
+    if (not agent_name.strip() or not input_signature.strip() or not output_signature.strip()):
         registered_tools = get_registered_items_service("tool")
         return templates.TemplateResponse(
             "partials/_agent_detail_form.html",
             {
-                "request": request,
-                "agent": None,
-                "is_new": True,
+                "request": request, "agent": None, "is_new": True,
                 "error_message": "Name, Input Signature, and Output Signature are required.",
-                "registered_tools": registered_tools,
-                "current_tools": tools,  # Pass back selected tools
-            },
-        )
+                "registered_tools": registered_tools, "current_tools": tools,
+            })
 
     agent_config = {
-        "name": agent_name,
-        "description": agent_description,
-        "model": agent_model
-        if agent_model
-        else None,  # Pass None if empty string for FlockFactory
-        "input": input_signature,
-        "output": output_signature,
-        "tools_names": tools,  # Pass tool names
+        "name": agent_name, "description": agent_description,
+        "model": agent_model if agent_model and agent_model.strip() else None,
+        "input": input_signature, "output": output_signature, "tools_names": tools,
     }
-    success = add_agent_to_current_flock_service(agent_config)
+    # Pass request.app.state to the service function
+    success = add_agent_to_current_flock_service(agent_config, request.app.state)
 
-    # After action, re-render the agent list and clear the detail form
-    # Set headers for HTMX to trigger multiple target updates
     response_headers = {}
     if success:
-        response_headers["HX-Trigger"] = (
-            "agentListChanged"  # Custom event to refresh list
-        )
+        response_headers["HX-Trigger"] = json.dumps({"agentListChanged": None, "notify": {"type":"success", "message": f"Agent '{agent_name}' created."}})
 
-    # Render an empty detail form or a success message for the detail panel
-    empty_detail_form = templates.TemplateResponse(
-        "partials/_agent_detail_form.html",
-        {
-            "request": request,
-            "agent": None,
-            "is_new": True,
-            "registered_tools": get_registered_items_service("tool"),
-            "form_message": "Agent created successfully!"
-            if success
-            else "Failed to create agent.",
-            "success": success,
-        },
-    ).body.decode()
 
-    return HTMLResponse(content=empty_detail_form, headers=response_headers)
+    # Re-render the form or an empty state for the detail panel
+    # The agent list itself will be refreshed by the agentListChanged trigger
+    new_form_context = {
+        "request": request, "agent": None, "is_new": True,
+        "registered_tools": get_registered_items_service("tool"),
+        "current_tools": [], # Reset tools for new form
+        "form_message": "Agent created successfully!" if success else "Failed to create agent. Check logs.",
+        "success": success,
+    }
+    return templates.TemplateResponse("partials/_agent_detail_form.html", new_form_context, headers=response_headers)
 
 
-@router.put(
-    "/htmx/agents/{original_agent_name}", response_class=HTMLResponse
-)  # For updating existing agent
+@router.put("/htmx/agents/{original_agent_name}", response_class=HTMLResponse)
 async def htmx_update_agent(
     request: Request,
     original_agent_name: str,
@@ -168,103 +166,76 @@ async def htmx_update_agent(
     input_signature: str = Form(...),
     output_signature: str = Form(...),
     tools: list[str] = Form([]),
+    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
 ):
-    flock = get_current_flock_instance()
-    if not flock:
-        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
-
     agent_config = {
-        "name": agent_name,
-        "description": agent_description,
-        "model": agent_model if agent_model else None,
-        "input": input_signature,
-        "output": output_signature,
-        "tools_names": tools,
+        "name": agent_name, "description": agent_description,
+        "model": agent_model if agent_model and agent_model.strip() else None,
+        "input": input_signature, "output": output_signature, "tools_names": tools,
     }
-    success = update_agent_in_current_flock_service(
-        original_agent_name, agent_config
-    )
+    # Pass request.app.state
+    success = update_agent_in_current_flock_service(original_agent_name, agent_config, request.app.state)
 
     response_headers = {}
     if success:
-        response_headers["HX-Trigger"] = "agentListChanged"
+        response_headers["HX-Trigger"] = json.dumps({"agentListChanged": None, "notify": {"type":"success", "message": f"Agent '{agent_name}' updated."}})
 
-    # Re-render the form with update message
-    updated_agent = flock.agents.get(
-        agent_name
-    )  # Get the potentially renamed agent
-    registered_tools = get_registered_items_service("tool")
-    current_tools = (
-        [tool.__name__ for tool in updated_agent.tools]
-        if updated_agent and updated_agent.tools
-        else []
-    )
-
-    updated_form = templates.TemplateResponse(
-        "partials/_agent_detail_form.html",
-        {
-            "request": request,
-            "agent": updated_agent,  # Pass the updated agent
-            "is_new": False,
-            "form_message": "Agent updated successfully!"
-            if success
-            else "Failed to update agent.",
-            "success": success,
-            "registered_tools": registered_tools,
-            "current_tools": current_tools,
-        },
-    ).body.decode()
-    return HTMLResponse(content=updated_form, headers=response_headers)
 
+    # After update, get the (potentially renamed) agent from app.state's flock
+    updated_agent_instance: Flock | None = getattr(request.app.state, 'flock_instance', None)
+    updated_agent = updated_agent_instance.agents.get(agent_name) if updated_agent_instance else None
 
-@router.delete("/htmx/agents/{agent_name}", response_class=HTMLResponse)
-async def htmx_delete_agent(request: Request, agent_name: str):
-    flock = get_current_flock_instance()
-    if not flock:
-        return HTMLResponse("")  # Return empty to clear detail view
+    registered_tools = get_registered_items_service("tool")
+    current_agent_tools = []
+    if updated_agent and updated_agent.tools:
+        current_agent_tools = [tool.__name__ for tool in updated_agent.tools]
+
+    updated_form_context = {
+        "request": request, "agent": updated_agent, "is_new": False,
+        "form_message": "Agent updated successfully!" if success else "Failed to update agent. Check logs.",
+        "success": success,
+        "registered_tools": registered_tools, "current_tools": current_agent_tools,
+    }
+    return templates.TemplateResponse("partials/_agent_detail_form.html", updated_form_context, headers=response_headers)
 
-    success = remove_agent_from_current_flock_service(agent_name)
 
+@router.delete("/htmx/agents/{agent_name}", response_class=HTMLResponse)
+async def htmx_delete_agent(
+    request: Request,
+    agent_name: str,
+    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
+):
+    # Pass request.app.state
+    success = remove_agent_from_current_flock_service(agent_name, request.app.state)
     response_headers = {}
+
     if success:
-        response_headers["HX-Trigger"] = "agentListChanged"
-        # Return an empty agent detail form to clear the panel
-        # Also, the agent list will re-render due to HX-Trigger
-        return HTMLResponse(
-            templates.TemplateResponse(
-                "partials/_agent_detail_form.html",
-                {
-                    "request": request,
-                    "agent": None,
-                    "is_new": True,
-                    "form_message": f"Agent '{agent_name}' removed.",
-                    "success": True,
-                    "registered_tools": get_registered_items_service("tool"),
-                },
-            ).body.decode(),
-            headers=response_headers,
-        )
+        response_headers["HX-Trigger"] = json.dumps({"agentListChanged": None, "notify": {"type":"info", "message": f"Agent '{agent_name}' removed."}})
+        # Return an empty agent detail form to clear that panel
+        empty_form_context = {
+            "request": request, "agent": None, "is_new": True,
+            "registered_tools": get_registered_items_service("tool"),
+            "current_tools": [],
+            # "form_message": f"Agent '{agent_name}' removed.", # Message handled by notify
+            # "success": True, # Not strictly needed if form is cleared
+        }
+        return templates.TemplateResponse("partials/_agent_detail_form.html", empty_form_context, headers=response_headers)
     else:
-        # If deletion fails, re-render the agent detail form with an error
-        # This scenario should be rare unless the agent was already removed
-        agent = flock.agents.get(
-            agent_name
-        )  # Should still exist if delete failed
+        # Deletion failed, re-render the form for the agent that failed to delete (if it still exists)
+        flock_instance_from_state: Flock | None = getattr(request.app.state, 'flock_instance', None)
+        agent_still_exists = flock_instance_from_state.agents.get(agent_name) if flock_instance_from_state else None
+
         registered_tools = get_registered_items_service("tool")
-        current_tools = (
-            [tool.__name__ for tool in agent.tools]
-            if agent and agent.tools
-            else []
-        )
-        return templates.TemplateResponse(
-            "partials/_agent_detail_form.html",
-            {
-                "request": request,
-                "agent": agent,
-                "is_new": False,
-                "form_message": f"Failed to remove agent '{agent_name}'.",
-                "success": False,
-                "registered_tools": registered_tools,
-                "current_tools": current_tools,
-            },
-        )
+        current_tools = []
+        if agent_still_exists and agent_still_exists.tools:
+            current_tools = [tool.__name__ for tool in agent_still_exists.tools]
+
+        error_form_context = {
+            "request": request, "agent": agent_still_exists, "is_new": False,
+            "form_message": f"Failed to remove agent '{agent_name}'. It might have already been removed or an error occurred.",
+            "success": False,
+            "registered_tools": registered_tools, "current_tools": current_tools,
+        }
+        # Trigger a notification for the error as well
+        response_headers["HX-Trigger"] = json.dumps({"notify": {"type":"error", "message": f"Failed to remove agent '{agent_name}'."}})
+        return templates.TemplateResponse("partials/_agent_detail_form.html", error_form_context, headers=response_headers)

flock/webapp/app/api/execution.py

@@ -1,14 +1,28 @@
+# src/flock/webapp/app/api/execution.py
 import json
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-from fastapi import APIRouter, Request
+from fastapi import APIRouter, Depends, Request  # Added Depends
 from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+
+
 from flock.core.util.spliter import parse_schema
+
+# Import the dependency to get the current Flock instance
+from flock.webapp.app.dependencies import (
+    get_flock_instance,
+    get_optional_flock_instance,
+)
+
+# Service function now takes app_state
 from flock.webapp.app.services.flock_service import (
-    get_current_flock_instance,
     run_current_flock_service,
+    # get_current_flock_instance IS NO LONGER IMPORTED
 )
 from flock.webapp.app.utils import pydantic_to_dict
 
@@ -17,32 +31,36 @@ BASE_DIR = Path(__file__).resolve().parent.parent.parent
 templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
 
 
-# RENAMED this endpoint to avoid clash and for clarity
 @router.get("/htmx/execution-form-content", response_class=HTMLResponse)
-async def htmx_get_execution_form_content(request: Request):  # Renamed function
-    flock = get_current_flock_instance()
+async def htmx_get_execution_form_content(
+    request: Request,
+    current_flock: "Flock | None" = Depends(get_optional_flock_instance) # Use optional if form can show 'no flock'
+):
+    # flock instance is injected
     return templates.TemplateResponse(
         "partials/_execution_form.html",
         {
             "request": request,
-            "flock": flock,
+            "flock": current_flock, # Pass the injected flock instance
             "input_fields": [],
-            "selected_agent_name": None,
+            "selected_agent_name": None, # Form starts with no agent selected
         },
     )
 
 
 @router.get("/htmx/agents/{agent_name}/input-form", response_class=HTMLResponse)
-async def htmx_get_agent_input_form(request: Request, agent_name: str):
-    # ... (same as before) ...
-    flock = get_current_flock_instance()
-    if not flock:
-        return HTMLResponse("")
-    agent = flock.agents.get(agent_name)
+async def htmx_get_agent_input_form(
+    request: Request,
+    agent_name: str,
+    current_flock: "Flock" = Depends(get_flock_instance) # Expect flock to be loaded
+):
+    # flock instance is injected
+    agent = current_flock.agents.get(agent_name)
     if not agent:
         return HTMLResponse(
-            f"<p class='error'>Agent '{agent_name}' not found.</p>"
+            f"<p class='error'>Agent '{agent_name}' not found in the current Flock.</p>"
         )
+
     input_fields = []
     if agent.input and isinstance(agent.input, str):
         try:
@@ -53,21 +71,12 @@ async def htmx_get_agent_input_form(request: Request, agent_name: str):
                     "type": type_str.lower(),
                     "description": description or "",
                 }
-                if "bool" in field_info["type"]:
-                    field_info["html_type"] = "checkbox"
-                elif (
-                    "int" in field_info["type"] or "float" in field_info["type"]
-                ):
-                    field_info["html_type"] = "number"
-                elif (
-                    "list" in field_info["type"] or "dict" in field_info["type"]
-                ):
+                if "bool" in field_info["type"]: field_info["html_type"] = "checkbox"
+                elif "int" in field_info["type"] or "float" in field_info["type"]: field_info["html_type"] = "number"
+                elif "list" in field_info["type"] or "dict" in field_info["type"]:
                     field_info["html_type"] = "textarea"
-                    field_info["placeholder"] = (
-                        f"Enter JSON for {field_info['type']}"
-                    )
-                else:
-                    field_info["html_type"] = "text"
+                    field_info["placeholder"] = f"Enter JSON for {field_info['type']}"
+                else: field_info["html_type"] = "text"
                 input_fields.append(field_info)
         except Exception as e:
             return HTMLResponse(
@@ -80,86 +89,68 @@ async def htmx_get_agent_input_form(request: Request, agent_name: str):
 
 
 @router.post("/htmx/run", response_class=HTMLResponse)
-async def htmx_run_flock(request: Request):
-    # ... (same as before, ensure it uses the correct _results_display.html) ...
-    flock = get_current_flock_instance()
-    if not flock:
+async def htmx_run_flock(
+    request: Request,
+    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
+):
+    # The service function run_current_flock_service now takes app_state
+    # We retrieve current_flock from app_state inside the service or before calling if needed for validation here
+
+    # It's better to get flock from app_state here to validate before calling service
+    current_flock: Flock | None = getattr(request.app.state, 'flock_instance', None)
+
+    if not current_flock:
         return HTMLResponse("<p class='error'>No Flock loaded to run.</p>")
+
     form_data = await request.form()
     start_agent_name = form_data.get("start_agent_name")
+
     if not start_agent_name:
         return HTMLResponse("<p class='error'>Starting agent not selected.</p>")
-    agent = flock.agents.get(start_agent_name)
+
+    agent = current_flock.agents.get(start_agent_name)
     if not agent:
         return HTMLResponse(
-            f"<p class='error'>Agent '{start_agent_name}' not found.</p>"
+            f"<p class='error'>Agent '{start_agent_name}' not found in the current Flock.</p>"
         )
+
     inputs = {}
     if agent.input and isinstance(agent.input, str):
         try:
             parsed_spec = parse_schema(agent.input)
             for name, type_str, _ in parsed_spec:
-                form_field_name = f"agent_input_{name}"
+                form_field_name = f"agent_input_{name}" # Matches the name in _dynamic_input_form_content.html
                 raw_value = form_data.get(form_field_name)
-                if raw_value is None and "bool" in type_str.lower():
-                    inputs[name] = False
-                    continue
-                if raw_value is None:
-                    inputs[name] = None
-                    continue
+
+                if raw_value is None and "bool" in type_str.lower(): inputs[name] = False; continue
+                if raw_value is None: inputs[name] = None; continue
+
                 if "int" in type_str.lower():
-                    try:
-                        inputs[name] = int(raw_value)
-                    except ValueError:
-                        return HTMLResponse(
-                            f"<p class='error'>Invalid integer for '{name}'.</p>"
-                        )
+                    try: inputs[name] = int(raw_value)
+                    except ValueError: return HTMLResponse(f"<p class='error'>Invalid integer for '{name}'.</p>")
                 elif "float" in type_str.lower():
-                    try:
-                        inputs[name] = float(raw_value)
-                    except ValueError:
-                        return HTMLResponse(
-                            f"<p class='error'>Invalid float for '{name}'.</p>"
-                        )
+                    try: inputs[name] = float(raw_value)
+                    except ValueError: return HTMLResponse(f"<p class='error'>Invalid float for '{name}'.</p>")
                 elif "bool" in type_str.lower():
-                    inputs[name] = raw_value.lower() in [
-                        "true",
-                        "on",
-                        "1",
-                        "yes",
-                    ]
+                    inputs[name] = raw_value.lower() in ["true", "on", "1", "yes"]
                 elif "list" in type_str.lower() or "dict" in type_str.lower():
-                    try:
-                        inputs[name] = json.loads(raw_value)
-                    except json.JSONDecodeError:
-                        return HTMLResponse(
-                            f"<p class='error'>Invalid JSON for '{name}'.</p>"
-                        )
-                else:
-                    inputs[name] = raw_value
+                    try: inputs[name] = json.loads(raw_value)
+                    except json.JSONDecodeError: return HTMLResponse(f"<p class='error'>Invalid JSON for '{name}'.</p>")
+                else: inputs[name] = raw_value
         except Exception as e:
-            return HTMLResponse(
-                f"<p class='error'>Error processing inputs for {start_agent_name}: {e}</p>"
-            )
+            return HTMLResponse(f"<p class='error'>Error processing inputs for {start_agent_name}: {e}</p>")
 
     try:
-        # Run the flock service and get the result
-        result_data = await run_current_flock_service(start_agent_name, inputs)
+        # Pass request.app.state to the service function
+        result_data = await run_current_flock_service(start_agent_name, inputs, request.app.state)
 
-        # Detect Pydantic models and convert to dictionaries
         try:
-            # Convert Pydantic models to dictionaries for JSON serialization
             result_data = pydantic_to_dict(result_data)
-
-            # Test JSON serialization to catch any remaining issues
-            try:
-                json.dumps(result_data)
-            except (TypeError, ValueError) as e:
-                # If JSON serialization fails, convert to a string representation
-                result_data = f"Error: Result contains non-serializable data: {e!s}\nOriginal result: {result_data!s}"
-
-        except Exception as e:
-            result_data = f"Error: Failed to process result data: {e!s}"
+            try: json.dumps(result_data)
+            except (TypeError, ValueError) as ser_e:
+                result_data = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result: {result_data!s}"
+        except Exception as proc_e:
+            result_data = f"Error: Failed to process result data: {proc_e!s}"
 
         return templates.TemplateResponse(
             "partials/_results_display.html",
@@ -169,5 +160,5 @@ async def htmx_run_flock(request: Request):
         error_message = f"Error during execution: {e!s}"
         return templates.TemplateResponse(
             "partials/_results_display.html",
-            {"request": request, "result_data": error_message},
+            {"request": request, "result_data": error_message}, # Display error in the same partial
         )