flock-core 0.4.0b48__tar.gz → 0.4.0b49__tar.gz

{flock_core-0.4.0b48 → flock_core-0.4.0b49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b48
+Version: 0.4.0b49
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -8,6 +8,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
+Requires-Dist: aiosqlite>=0.21.0
 Requires-Dist: chromadb>=0.6.3
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: datasets>=3.2.0
@@ -18,7 +19,9 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: inspect-ai>=0.3.88
 Requires-Dist: litellm==1.69.3
 Requires-Dist: loguru>=0.7.3
+Requires-Dist: markdown2>=2.5.3
 Requires-Dist: matplotlib>=3.10.0
+Requires-Dist: mem0ai[graph]>=0.1.100
 Requires-Dist: msgpack>=1.1.0
 Requires-Dist: notion-client>=2.3.0
 Requires-Dist: openai==1.75.0
@@ -47,7 +50,6 @@ Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.10.2
 Requires-Dist: tqdm>=4.67.1
 Requires-Dist: uvicorn>=0.34.0
-Requires-Dist: zep-python>=2.0.2
 Provides-Extra: all-tools
 Requires-Dist: azure-identity>=1.23.0; extra == 'all-tools'
 Requires-Dist: azure-search-documents>=11.5.2; extra == 'all-tools'

flock_core-0.4.0b49/main.md

@@ -0,0 +1,54 @@
+\
+```python
+# Add these imports to the appropriate sections of src/flock/webapp/app/main.py
+
+# Standard library imports (if not already present)
+import uuid
+
+# Pydantic and FastAPI imports (ensure these are grouped with similar imports)
+from pydantic import BaseModel
+from fastapi import Depends, HTTPException 
+
+# Imports from your project for the sharing feature
+from flock.webapp.app.services.sharing_models import SharedLinkConfig
+from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
+from flock.webapp.app.dependencies import get_shared_link_store
+```
+
+```python
+# Add this code block in src/flock/webapp/app/main.py
+# A good place is after the app.include_router(...) lines 
+# and before other utility function definitions or page route definitions.
+
+# --- Share Link API Models and Endpoint ---
+class CreateShareLinkRequest(BaseModel):
+    agent_name: str
+
+class CreateShareLinkResponse(BaseModel):
+    share_url: str
+
+@app.post("/api/v1/share/link", response_model=CreateShareLinkResponse, tags=["UI Sharing"])
+async def create_share_link(
+    request_data: CreateShareLinkRequest,
+    store: SharedLinkStoreInterface = Depends(get_shared_link_store)
+):
+    \"\"\"Creates a new shareable link for an agent.\"\"\"
+    share_id = uuid.uuid4().hex
+    agent_name = request_data.agent_name
+
+    if not agent_name: # Basic validation
+        raise HTTPException(status_code=400, detail="Agent name cannot be empty.")
+
+    config = SharedLinkConfig(share_id=share_id, agent_name=agent_name)
+    try:
+        await store.save_config(config)
+        share_url = f"/ui/shared-run/{share_id}\" # Relative URL
+        # Ensure 'logger' is available in this scope, e.g., defined globally in main.py
+        logger.info(f"Created share link for agent \'{agent_name}\' with ID \'{share_id}\'. URL: {share_url}")
+        return CreateShareLinkResponse(share_url=share_url)
+    except Exception as e:
+        logger.error(f"Failed to create share link for agent \'{agent_name}\': {e}", exc_info=True)
+        # The f-string formatting for the exception detail was corrected here.
+        raise HTTPException(status_code=500, detail=f"Failed to create share link: {str(e)}")
+
+# --- End Share Link API --- 

{flock_core-0.4.0b48 → flock_core-0.4.0b49}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.0b-48"
+version = "0.4.0b-49"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [
@@ -52,7 +52,9 @@ dependencies = [
     "toml>=0.10.2",
     "tqdm>=4.67.1",
     "uvicorn>=0.34.0",
-    "zep-python>=2.0.2",
+    "mem0ai[graph]>=0.1.100",
+    "aiosqlite>=0.21.0",
+    "markdown2>=2.5.3",
 ]
 
 [project.optional-dependencies]

{flock_core-0.4.0b48 → flock_core-0.4.0b49}/src/flock/__init__.py

@@ -16,6 +16,11 @@ def main():
         action="store_true",
         help="Start the web interface instead of the CLI",
     )
+    parser.add_argument(
+        "--chat",
+        action="store_true",
+        help="Start a chat interface. If --web is also used, enables chat within the web app; otherwise, starts standalone chat.",
+    )
     parser.add_argument(
         "--theme",
         type=str,
@@ -30,7 +35,7 @@ def main():
             # Set environment variable for theme if provided
             if args.theme:
                 print(
-                    f"Setting FLOCK_WEB_THEME environment variable to: {args.theme}"
+                    f"INFO: Setting FLOCK_WEB_THEME environment variable to: {args.theme}"
                 )
                 os.environ["FLOCK_WEB_THEME"] = args.theme
             else:
@@ -38,10 +43,20 @@ def main():
                 if "FLOCK_WEB_THEME" in os.environ:
                     del os.environ["FLOCK_WEB_THEME"]
 
+            if args.chat: # --web --chat
+                print("INFO: Starting web application with chat feature enabled.")
+                os.environ["FLOCK_CHAT_ENABLED"] = "true"
+            else: # Just --web
+                print("INFO: Starting web application.")
+                if "FLOCK_CHAT_ENABLED" in os.environ:
+                    del os.environ["FLOCK_CHAT_ENABLED"]
+
+            # Ensure standalone chat mode is not active
+            if "FLOCK_START_MODE" in os.environ:
+                 del os.environ["FLOCK_START_MODE"]
+
             # Import and run the standalone webapp main function
-            # It will now read the theme from the environment variable
             from flock.webapp.run import main as run_webapp_main
-
             run_webapp_main()
 
         except ImportError:
@@ -55,6 +70,33 @@ def main():
             sys.exit(1)
         return
 
+    elif args.chat: # Standalone chat mode (args.web is false)
+        try:
+            print("INFO: Starting standalone chat application.")
+            os.environ["FLOCK_START_MODE"] = "chat"
+
+            # Clear web-specific env vars that might conflict or not apply
+            if "FLOCK_WEB_THEME" in os.environ:
+                del os.environ["FLOCK_WEB_THEME"]
+            if "FLOCK_CHAT_ENABLED" in os.environ:
+                del os.environ["FLOCK_CHAT_ENABLED"]
+
+            # Handle --theme if passed with --chat only
+            if args.theme:
+                 print(f"INFO: Standalone chat mode started with --theme '{args.theme}'. FLOCK_WEB_THEME will be set.")
+                 os.environ["FLOCK_WEB_THEME"] = args.theme
+
+            from flock.webapp.run import main as run_webapp_main
+            run_webapp_main() # The webapp main needs to interpret FLOCK_START_MODE="chat"
+
+        except ImportError:
+            print("Error: Could not import webapp components for chat. Ensure web dependencies are installed.", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error starting standalone chat application: {e}", file=sys.stderr)
+            sys.exit(1)
+        return
+
     # Otherwise, run the CLI interface
     import questionary
     from rich.console import Console

flock_core-0.4.0b49/src/flock/modules/mem0/mem0_module.py

@@ -0,0 +1,63 @@
+from typing import Any
+
+from pydantic import Field
+
+from flock.core.context.context import FlockContext
+from flock.core.flock_agent import FlockAgent
+from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.flock_registry import flock_component
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("module.mem0")
+
+
+class Mem0ModuleConfig(FlockModuleConfig):
+    qdrant_host: str = Field(default="localhost", description="Qdrant hostname")
+    qdrant_port: int = Field(default=6333, description="Qdrant port")
+    collection: str = Field(default="flock_memories", description="Vector collection")
+    embedder_provider: str = Field(default="openai", description="'openai' or 'local'")
+    embedder_model: str = Field(default="text-embedding-ada-002",
+                                description="Model name for embeddings")
+    # Optional: allow separate LLM for reflection/summarisation
+    llm_provider: str | None = Field(default=None)
+    llm_model: str | None = Field(default=None)
+    top_k: int = Field(default=5, description="Number of memories to retrieve")
+
+
+
+@flock_component(config_class=Mem0ModuleConfig)
+class Mem0Module(FlockModule):
+    """Module that adds Zep capabilities to a Flock agent."""
+
+    name: str = "mem0"
+    config: Mem0ModuleConfig = Mem0ModuleConfig()
+    session_id: str | None = None
+    user_id: str | None = None
+
+    def __init__(self, name, config: Mem0ModuleConfig) -> None:
+        """Initialize Mem0 module."""
+        super().__init__(name=name, config=config)
+        logger.debug("Initializing Mem0 module")
+
+
+    async def on_post_evaluate(
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+        result: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+
+        return result
+
+    async def on_pre_evaluate(
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+    ) -> dict[str, Any]:
+
+
+
+
+        return inputs

flock_core-0.4.0b49/src/flock/modules/mem0graph/mem0_graph_module.py

@@ -0,0 +1,63 @@
+from typing import Any
+
+from pydantic import Field
+
+from flock.core.context.context import FlockContext
+from flock.core.flock_agent import FlockAgent
+from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.flock_registry import flock_component
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("module.mem0")
+
+
+class Mem0GraphModuleConfig(FlockModuleConfig):
+    qdrant_host: str = Field(default="localhost", description="Qdrant hostname")
+    qdrant_port: int = Field(default=6333, description="Qdrant port")
+    collection: str = Field(default="flock_memories", description="Vector collection")
+    embedder_provider: str = Field(default="openai", description="'openai' or 'local'")
+    embedder_model: str = Field(default="text-embedding-ada-002",
+                                description="Model name for embeddings")
+    # Optional: allow separate LLM for reflection/summarisation
+    llm_provider: str | None = Field(default=None)
+    llm_model: str | None = Field(default=None)
+    top_k: int = Field(default=5, description="Number of memories to retrieve")
+
+
+
+@flock_component(config_class=Mem0GraphModuleConfig)
+class Mem0GraphModule(FlockModule):
+
+
+    name: str = "mem0"
+    config: Mem0GraphModuleConfig = Mem0GraphModuleConfig()
+    session_id: str | None = None
+    user_id: str | None = None
+
+    def __init__(self, name, config: Mem0GraphModuleConfig) -> None:
+        """Initialize Mem0 module."""
+        super().__init__(name=name, config=config)
+        logger.debug("Initializing Mem0 module")
+
+
+    async def on_post_evaluate(
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+        result: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+
+        return result
+
+    async def on_pre_evaluate(
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+    ) -> dict[str, Any]:
+
+
+
+
+        return inputs

flock_core-0.4.0b49/src/flock/modules/performance/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock_core-0.4.0b49/src/flock/webapp/app/api/execution.py

@@ -0,0 +1,264 @@
+# src/flock/webapp/app/api/execution.py
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from fastapi import (  # Ensure Form and HTTPException are imported
+    APIRouter,
+    Depends,
+    Form,
+    Request,
+)
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+
+
+from flock.core.flock import (
+    Flock as ConcreteFlock,  # For creating Flock instance
+)
+from flock.core.logging.logging import (
+    get_logger as get_flock_logger,  # For logging within the new endpoint
+)
+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 (
+    run_current_flock_service,
+    # get_current_flock_instance IS NO LONGER IMPORTED
+)
+from flock.webapp.app.utils import pydantic_to_dict
+
+router = APIRouter()
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+
+@router.get("/htmx/execution-form-content", response_class=HTMLResponse)
+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": current_flock, # Pass the injected flock instance
+            "input_fields": [],
+            "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,
+    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 in the current Flock.</p>"
+        )
+
+    input_fields = []
+    if agent.input and isinstance(agent.input, str):
+        try:
+            parsed_spec = parse_schema(agent.input)
+            for name, type_str, description in parsed_spec:
+                field_info = {
+                    "name": name,
+                    "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"]:
+                    field_info["html_type"] = "textarea"
+                    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(
+                f"<p class='error'>Error parsing input signature for {agent_name}: {e}</p>"
+            )
+    return templates.TemplateResponse(
+        "partials/_dynamic_input_form_content.html",
+        {"request": request, "input_fields": input_fields},
+    )
+
+
+@router.post("/htmx/run", response_class=HTMLResponse)
+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_from_state: Flock | None = getattr(request.app.state, 'flock_instance', None)
+    logger = get_flock_logger("webapp.execution.regular_run") # Standard logger
+
+    if not current_flock_from_state:
+        logger.error("HTMX Run (Regular): No Flock loaded in app_state.")
+        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:
+        logger.warning("HTMX Run (Regular): Starting agent not selected.")
+        return HTMLResponse("<p class='error'>Starting agent not selected.</p>")
+
+    agent = current_flock_from_state.agents.get(start_agent_name)
+    if not agent:
+        logger.error(f"HTMX Run (Regular): Agent '{start_agent_name}' not found in Flock '{current_flock_from_state.name}'.")
+        return HTMLResponse(
+            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}"
+                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 "int" in type_str.lower(): inputs[name] = int(raw_value)
+                elif "float" in type_str.lower(): inputs[name] = float(raw_value)
+                elif "bool" in type_str.lower(): inputs[name] = raw_value.lower() in ["true", "on", "1", "yes"]
+                elif "list" in type_str.lower() or "dict" in type_str.lower(): inputs[name] = json.loads(raw_value)
+                else: inputs[name] = raw_value
+        except ValueError as ve:
+            logger.error(f"HTMX Run (Regular): Input parsing error for agent '{start_agent_name}': {ve}", exc_info=True)
+            return HTMLResponse(f"<p class='error'>Invalid input format: {ve!s}</p>")
+        except Exception as e_parse:
+            logger.error(f"HTMX Run (Regular): Error processing inputs for '{start_agent_name}': {e_parse}", exc_info=True)
+            return HTMLResponse(f"<p class='error'>Error processing inputs for {start_agent_name}: {e_parse}</p>")
+
+    try:
+        logger.info(f"HTMX Run (Regular): Executing agent '{start_agent_name}' from Flock '{current_flock_from_state.name}' via service.")
+        result_data = await run_current_flock_service(start_agent_name, inputs, request.app.state)
+    except Exception as e_run:
+        logger.error(f"HTMX Run (Regular): Error during service execution for '{start_agent_name}': {e_run}", exc_info=True)
+        return templates.TemplateResponse(
+            "partials/_results_display.html",
+            {"request": request, "result_data": {"error": f"Error during execution: {e_run!s}"}},
+        )
+
+    # Process and serialize result for template
+    try:
+        processed_result = pydantic_to_dict(result_data)
+        try: json.dumps(processed_result)
+        except (TypeError, ValueError) as ser_e:
+            processed_result = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result preview: {str(result_data)[:500]}..."
+            logger.warning(f"HTMX Run (Regular): Serialization issue: {processed_result}")
+    except Exception as proc_e:
+        processed_result = f"Error: Failed to process result data: {proc_e!s}"
+        logger.error(f"HTMX Run (Regular): Result processing error: {processed_result}", exc_info=True)
+
+    return templates.TemplateResponse(
+        "partials/_results_display.html",
+        {"request": request, "result_data": processed_result},
+    )
+
+
+# --- NEW ENDPOINT FOR SHARED RUNS ---
+@router.post("/htmx/run-shared", response_class=HTMLResponse)
+async def htmx_run_shared_flock(
+    request: Request,
+    share_id: str = Form(...), # Expect share_id from the form
+    # flock_definition_str: str = Form(...), # No longer needed
+    # start_agent_name from form is still required implicitly via form_data.get()
+    # No DI for current_flock, as we are using the one from app.state via share_id
+):
+    shared_logger = get_flock_logger("webapp.execution.shared_run_stateful")
+    form_data = await request.form()
+    start_agent_name = form_data.get("start_agent_name")
+
+    if not start_agent_name:
+        shared_logger.warning("HTMX Run Shared (Stateful): Starting agent name not provided in form.")
+        return HTMLResponse("<p class='error'>Critical error: Starting agent name missing from shared run form.</p>")
+
+    shared_logger.info(f"HTMX Run Shared (Stateful): Attempting to execute agent '{start_agent_name}' using pre-loaded Flock for share_id '{share_id}'.")
+
+    inputs = {}
+    result_data: Any = None
+    temp_flock: ConcreteFlock | None = None
+
+    try:
+        # Retrieve the pre-loaded Flock instance from app.state
+        shared_flocks_store = getattr(request.app.state, 'shared_flocks', {})
+        temp_flock = shared_flocks_store.get(share_id)
+
+        if not temp_flock:
+            shared_logger.error(f"HTMX Run Shared: Flock instance for share_id '{share_id}' not found in app.state.")
+            return HTMLResponse(f"<p class='error'>Shared session not found or expired. Please try accessing the shared link again.</p>")
+
+        shared_logger.info(f"HTMX Run Shared: Successfully retrieved pre-loaded Flock '{temp_flock.name}' for agent '{start_agent_name}' (share_id: {share_id}).")
+
+        agent = temp_flock.agents.get(start_agent_name)
+        if not agent:
+            shared_logger.error(f"HTMX Run Shared: Agent '{start_agent_name}' not found in shared Flock '{temp_flock.name}'.")
+            return HTMLResponse(f"<p class='error'>Agent '{start_agent_name}' not found in the provided shared Flock definition.</p>")
+
+        # Parse inputs for the agent from the temporary flock
+        if agent.input and isinstance(agent.input, str):
+            parsed_spec = parse_schema(agent.input)
+            for name, type_str, _ in parsed_spec:
+                form_field_name = f"agent_input_{name}" # Name used in shared_run_page.html
+                raw_value = form_data.get(form_field_name)
+
+                # Input type conversion (consistent with the other endpoint)
+                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(): inputs[name] = int(raw_value)
+                elif "float" in type_str.lower(): inputs[name] = float(raw_value)
+                elif "bool" in type_str.lower(): inputs[name] = raw_value.lower() in ["true", "on", "1", "yes"]
+                elif "list" in type_str.lower() or "dict" in type_str.lower(): inputs[name] = json.loads(raw_value)
+                else: inputs[name] = raw_value
+
+        shared_logger.info(f"HTMX Run Shared: Executing agent '{start_agent_name}' in pre-loaded Flock '{temp_flock.name}'. Inputs: {list(inputs.keys())}")
+        result_data = await temp_flock.run_async(start_agent=start_agent_name, input=inputs, box_result=False)
+        shared_logger.info(f"HTMX Run Shared: Agent '{start_agent_name}' executed. Result keys: {list(result_data.keys()) if isinstance(result_data, dict) else 'N/A'}")
+
+        # Process and serialize result for template (same logic as other endpoint)
+        try:
+            processed_result = pydantic_to_dict(result_data)
+            try: json.dumps(processed_result)
+            except (TypeError, ValueError) as ser_e:
+                processed_result = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result preview: {str(result_data)[:500]}..."
+                shared_logger.warning(f"HTMX Run Shared: Serialization issue: {processed_result}")
+        except Exception as proc_e:
+            processed_result = f"Error: Failed to process result data: {proc_e!s}"
+            shared_logger.error(f"HTMX Run Shared: Result processing error: {processed_result}", exc_info=True)
+
+        return templates.TemplateResponse(
+            "partials/_results_display.html",
+            {"request": request, "result_data": processed_result},
+        )
+
+    except ValueError as ve: # Catch specific input parsing errors
+        shared_logger.error(f"HTMX Run Shared: Input parsing error for agent '{start_agent_name}': {ve}", exc_info=True)
+        return HTMLResponse(f"<p class='error'>Invalid input format: {ve!s}</p>")
+    except Exception as e_general:
+        error_message = f"An unexpected error occurred during shared execution: {e_general!s}"
+        shared_logger.error(f"HTMX Run Shared: General error for agent '{start_agent_name}': {e_general}", exc_info=True)
+        return templates.TemplateResponse(
+            "partials/_results_display.html",
+            {"request": request, "result_data": {"error": error_message } },
+        )