flock-core 0.4.0b48__py3-none-any.whl → 0.4.0b49__py3-none-any.whl

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/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/modules/mem0graph/__init__.py

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

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/webapp/app/api/execution.py

@@ -1,9 +1,14 @@
 # src/flock/webapp/app/api/execution.py
 import json
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
-from fastapi import APIRouter, Depends, Request  # Added Depends
+from fastapi import (  # Ensure Form and HTTPException are imported
+    APIRouter,
+    Depends,
+    Form,
+    Request,
+)
 from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 
@@ -11,6 +16,12 @@ 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
@@ -97,19 +108,23 @@ async def htmx_run_flock(
     # 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)
+    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:
+    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.agents.get(start_agent_name)
+    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>"
         )
@@ -119,46 +134,131 @@ async def htmx_run_flock(
         try:
             parsed_spec = parse_schema(agent.input)
             for name, type_str, _ in parsed_spec:
-                form_field_name = f"agent_input_{name}" # Matches the name in _dynamic_input_form_content.html
+                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():
-                    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>")
-                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():
-                    try: inputs[name] = json.loads(raw_value)
-                    except json.JSONDecodeError: return HTMLResponse(f"<p class='error'>Invalid JSON for '{name}'.</p>")
+                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 Exception as e:
-            return HTMLResponse(f"<p class='error'>Error processing inputs for {start_agent_name}: {e}</p>")
+        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:
-        # Pass request.app.state to the service function
+        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:
-            result_data = pydantic_to_dict(result_data)
-            try: json.dumps(result_data)
+            processed_result = pydantic_to_dict(result_data)
+            try: json.dumps(processed_result)
             except (TypeError, ValueError) as ser_e:
-                result_data = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result: {result_data!s}"
+                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:
-            result_data = f"Error: Failed to process result data: {proc_e!s}"
+            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": result_data},
+            {"request": request, "result_data": processed_result},
         )
-    except Exception as e:
-        error_message = f"Error during execution: {e!s}"
+
+    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_message}, # Display error in the same partial
+            {"request": request, "result_data": {"error": error_message } },
         )