flock-core 0.4.519__py3-none-any.whl → 0.5.0b1__py3-none-any.whl

flock/core/serialization/serialization_utils.py

@@ -24,13 +24,13 @@ from pydantic import BaseModel
 if TYPE_CHECKING:
     pass
 
-from flock.core.flock_registry import get_registry
+from flock.core.registry import get_registry
 from flock.core.logging.logging import get_logger
 
 logger = get_logger("serialization.utils")
 
 # Remove this line to avoid circular import at module level
-# FlockRegistry = get_registry()  # Get singleton instance
+# registry = get_registry()  # Get singleton instance
 
 # --- Serialization Helper ---
 
@@ -188,16 +188,16 @@ def collect_pydantic_models(
 
 def serialize_item(item: Any) -> Any:
     """Recursively prepares an item for serialization (e.g., to dict for YAML/JSON).
-    Converts known callables to their path strings using FlockRegistry.
+    Converts known callables to their path strings using registry.
     Converts Pydantic models using model_dump.
     """
     # Import the registry lazily when needed
-    from flock.core.flock_registry import get_registry
+    from flock.core.registry import get_registry
 
-    FlockRegistry = get_registry()
+    registry = get_registry()
 
     if callable(item) and not isinstance(item, type):
-        path_str = FlockRegistry.get_callable_path_string(
+        path_str = registry.get_callable_path_string(
             item
         )  # Use registry helper
         if path_str:
@@ -248,12 +248,12 @@ def serialize_item(item: Any) -> Any:
     elif isinstance(
         item, type
     ):  # Handle type objects themselves (e.g. if stored directly)
-        type_name = FlockRegistry.get_component_type_name(
+        type_name = registry.get_component_type_name(
             item
         )  # Check components first
         if type_name:
             return {"__component_ref__": type_name}
-        type_name = FlockRegistry._get_path_string(
+        type_name = registry._get_path_string(
             item
         )  # Check regular types/classes by path
         if type_name:
@@ -274,13 +274,13 @@ def serialize_item(item: Any) -> Any:
 
 def deserialize_item(item: Any) -> Any:
     """Recursively processes a deserialized item (e.g., from YAML/JSON dict).
-    Converts reference dicts back to actual callables or types using FlockRegistry.
+    Converts reference dicts back to actual callables or types using registry.
     Handles nested lists and dicts.
     """
     # Import the registry lazily when needed
-    from flock.core.flock_registry import get_registry
+    from flock.core.registry import get_registry
 
-    FlockRegistry = get_registry()
+    registry = get_registry()
 
     if isinstance(item, Mapping):
         if "__callable_ref__" in item and len(item) == 1:
@@ -288,7 +288,7 @@ def deserialize_item(item: Any) -> Any:
             try:
                 # The registry's get_callable needs to handle lookup by simple name OR full path
                 # Or we assume get_callable handles finding the right function from the simple name
-                resolved_callable = FlockRegistry.get_callable(ref_name)
+                resolved_callable = registry.get_callable(ref_name)
                 logger.debug(
                     f"Deserialized callable reference '{ref_name}' to {resolved_callable}"
                 )
@@ -307,7 +307,7 @@ def deserialize_item(item: Any) -> Any:
         elif "__component_ref__" in item and len(item) == 1:
             type_name = item["__component_ref__"]
             try:
-                return FlockRegistry.get_component(type_name)
+                return registry.get_component(type_name)
             except KeyError:
                 logger.error(
                     f"Component reference '{type_name}' not found during deserialization."
@@ -318,7 +318,7 @@ def deserialize_item(item: Any) -> Any:
             try:
                 # For general types, use get_type or fallback to dynamic import like get_callable
                 # Using get_type for now, assuming it needs registration
-                return FlockRegistry.get_type(type_name)
+                return registry.get_type(type_name)
             except KeyError:
                 # Attempt dynamic import as fallback if get_type fails (similar to get_callable)
                 try:
@@ -329,7 +329,7 @@ def deserialize_item(item: Any) -> Any:
                         mod = importlib.import_module(module_name)
                     type_obj = getattr(mod, class_name)
                     if isinstance(type_obj, type):
-                        FlockRegistry.register_type(
+                        registry.register_type(
                             type_obj, type_name
                         )  # Cache it
                         return type_obj
@@ -356,12 +356,12 @@ def deserialize_component(
     data: dict | None, expected_base_type: type
 ) -> Any | None:
     """Deserializes a component (Module, Evaluator, Router) from its dict representation.
-    Uses the 'type' field to find the correct class via FlockRegistry.
+    Uses the 'type' field to find the correct class via registry.
     """
     # Import the registry and COMPONENT_BASE_TYPES lazily when needed
-    from flock.core.flock_registry import COMPONENT_BASE_TYPES, get_registry
+    from flock.core.registry import get_registry
 
-    FlockRegistry = get_registry()
+    registry = get_registry()
 
     if data is None:
         return None
@@ -379,14 +379,17 @@ def deserialize_component(
         return None
 
     try:
-        ComponentClass = FlockRegistry.get_component(type_name)  # Use registry
+        ComponentClass = registry.get_component(type_name)  # Use registry
         # Optional: Keep the base type check
-        if COMPONENT_BASE_TYPES and not issubclass(
-            ComponentClass, expected_base_type
-        ):
-            raise TypeError(
-                f"Deserialized class {type_name} is not a subclass of {expected_base_type.__name__}"
-            )
+        try:
+            from flock.core.component.agent_component_base import AgentComponent
+            if not issubclass(ComponentClass, AgentComponent):
+                logger.warning(
+                    f"Deserialized class '{type_name}' is not a subclass of AgentComponent."
+                )
+        except ImportError:
+            # AgentComponent not available during setup
+            pass
 
         # Recursively deserialize the data *before* passing to Pydantic constructor
         # This handles nested callables/types within the component's config/data

flock/core/util/input_resolver.py

@@ -45,7 +45,12 @@ def top_level_to_keys(s: str) -> list[str]:
 
 
 def resolve_inputs(
-    input_spec: str, context: FlockContext, previous_agent_name: str
+    input_spec: str,
+    context: FlockContext,
+    previous_agent_name: str,
+    previous_agent_output:str,
+    previous_agent_handoff_strategy:str,
+    previous_agent_handoff_map:dict[str, str]
 ) -> dict:
     """Build a dictionary of inputs based on the input specification string and the provided context.
 
@@ -63,6 +68,28 @@ def resolve_inputs(
         eg. agent name: "idea_agent", variable: "ia_idea" (ia = idea agent)
         - or set hand off mode to strict to avoid conflicts.
         with strict mode, the agent will only accept inputs from the previous agent.
+        
+
+    Strategy for passing data to the next agent.
+
+    Example:
+    ReviewAgent.next_agent = SummaryAgent
+    ReviewAgent(output = "text:str, keywords:list[str], rating:int")
+    SummaryAgent(input = "text:str, title:str")
+
+    'append' means the difference in signature is appended to the next agent's input signature.
+    SummaryAgent(input = "text:str, title:str, keywords:list[str], rating:int")
+
+    'override' means the target agent's signature is getting overriden.
+    SummaryAgent(input = "text:str, keywords:list[str], rating:int")
+
+    'static' means the the target agent's signature is not changed at all.
+    If source agent has no output fields that match the target agent's input,
+    there will be no data passed to the next agent.
+    SummaryAgent(input = "text:str, title:str")
+
+    'map' means the source agent's output is mapped to the target agent's input
+    based on 'handoff_map' configuration.
 
     Args:
         input_spec: Comma-separated input keys (e.g., "query" or "agent_name.property").
@@ -120,7 +147,7 @@ def resolve_inputs(
                 inputs[key] = context.get_agent_definition(property_name)
                 continue
 
-            # Otherwise, attempt to look up a state variable with the key "agent_name.property"
+            # Otherwise, attempt to look up a state variable with the key "entity_name.property_name"
             inputs[key] = context.get_variable(f"{entity_name}.{property_name}")
             continue
 

flock/platform/docker_tools.py

@@ -1,5 +1,5 @@
+import asyncio
 import subprocess
-import time
 
 
 def _check_docker_running():
@@ -16,7 +16,7 @@ def _check_docker_running():
         return False
 
 
-def _start_docker():
+async def _start_docker():
     """Attempt to start Docker.
     This example first tries 'systemctl start docker' and then 'service docker start'.
     Adjust as needed for your environment.
@@ -37,7 +37,7 @@ def _start_docker():
                 text=True,
             )
         # Give Docker a moment to start.
-        time.sleep(3)
+        await asyncio.sleep(3)
         if _check_docker_running():
             print("Docker is now running.")
             return True

flock/tools/markdown_tools.py

@@ -26,8 +26,7 @@ def markdown_split_by_headers(
     chunks = []
 
     # Process each section
-    for i in range(len(headers)):
-        current_header = headers[i]
+    for i, current_header in enumerate(headers):
         header_text = current_header.group(2).strip()
         header_level = len(current_header.group(1))
 

flock/tools/text_tools.py

@@ -206,8 +206,7 @@ def text_split_code_by_functions(code: str) -> list[dict[str, Any]]:
     functions = []
 
     # Process each function
-    for i in range(len(matches)):
-        current_match = matches[i]
+    for i, current_match in enumerate(matches):
         function_name = current_match.group(2)
 
         # Determine function content

flock/webapp/app/main.py

@@ -124,6 +124,10 @@ def mask_sensitive_value_web(value: str) -> str:
     if len(value) <= 4: return "••••"
     return value[:2] + "•" * (len(value) - 4) + value[-2:]
 
+def create_hx_trigger_header(triggers: dict[str, Any]) -> str:
+    """Helper function to create HX-Trigger header with JSON serialization."""
+    return json.dumps(triggers)
+
 def get_show_secrets_setting_web(env_vars: dict[str, str]) -> bool:
     return env_vars.get(SHOW_SECRETS_KEY, "false").lower() == "true"
 
@@ -843,12 +847,12 @@ async def ui_load_flock_by_name_action(request: Request, selected_flock_filename
     if loaded_flock:
         success_message_text = f"Flock '{loaded_flock.name}' loaded from '{selected_flock_filename}'."
         response_headers["HX-Push-Url"] = "/ui/editor/execute?ui_mode=" + ui_mode_query
-        response_headers["HX-Trigger"] = json.dumps({"flockLoaded": None, "notify": {"type": "success", "message": success_message_text}})
+        response_headers["HX-Trigger"] = create_hx_trigger_header({"flockLoaded": None, "notify": {"type": "success", "message": success_message_text}})
         context = get_base_context_web(request, success=success_message_text, ui_mode=ui_mode_query)
         return templates.TemplateResponse("partials/_execution_view_container.html", context, headers=response_headers)
     else:
         error_message_text = f"Failed to load flock file '{selected_flock_filename}'."
-        response_headers["HX-Trigger"] = json.dumps({"notify": {"type": "error", "message": error_message_text}})
+        response_headers["HX-Trigger"] = create_hx_trigger_header({"notify": {"type": "error", "message": error_message_text}})
         context = get_base_context_web(request, error=error_message_text, ui_mode=ui_mode_query)
         context["error_message_inline"] = error_message_text # For direct display in partial
         return templates.TemplateResponse("partials/_load_manager_view.html", context, headers=response_headers)
@@ -874,13 +878,13 @@ async def ui_load_flock_by_upload_action(request: Request, flock_file_upload: Up
         if loaded_flock:
             success_message_text = f"Flock '{loaded_flock.name}' loaded from '{filename_to_load}'."
             response_headers["HX-Push-Url"] = f"/ui/editor/execute?ui_mode={ui_mode_query}"
-            response_headers["HX-Trigger"] = json.dumps({"flockLoaded": None, "flockFileListChanged": None, "notify": {"type": "success", "message": success_message_text}})
+            response_headers["HX-Trigger"] = create_hx_trigger_header({"flockLoaded": None, "flockFileListChanged": None, "notify": {"type": "success", "message": success_message_text}})
             context = get_base_context_web(request, success=success_message_text, ui_mode=ui_mode_query)
             return templates.TemplateResponse("partials/_execution_view_container.html", context, headers=response_headers)
         else: error_message_text = f"Failed to process uploaded '{filename_to_load}'."
 
     final_error_msg = error_message_text or "Upload failed."
-    response_headers["HX-Trigger"] = json.dumps({"notify": {"type": "error", "message": final_error_msg}})
+    response_headers["HX-Trigger"] = create_hx_trigger_header({"notify": {"type": "error", "message": final_error_msg}})
     context = get_base_context_web(request, error=final_error_msg, ui_mode=ui_mode_query)
     return templates.TemplateResponse("partials/_create_flock_form.html", context, headers=response_headers)
 
@@ -893,7 +897,7 @@ async def ui_create_flock_action(request: Request, flock_name: str = Form(...),
 
     new_flock = create_new_flock_service(flock_name, default_model, description, request.app.state)
     success_msg_text = f"New flock '{new_flock.name}' created. Navigating to Execute page. Configure properties and agents as needed."
-    response_headers = {"HX-Push-Url": f"/ui/editor/execute?ui_mode={ui_mode_query}", "HX-Trigger": json.dumps({"flockLoaded": None, "notify": {"type": "success", "message": success_msg_text}})}
+    response_headers = {"HX-Push-Url": f"/ui/editor/execute?ui_mode={ui_mode_query}", "HX-Trigger": create_hx_trigger_header({"flockLoaded": None, "notify": {"type": "success", "message": success_msg_text}})}
     context = get_base_context_web(request, success=success_msg_text, ui_mode=ui_mode_query)
     return templates.TemplateResponse("partials/_execution_view_container.html", context, headers=response_headers)
 

flock/workflow/activities.py

@@ -7,15 +7,28 @@ from temporalio import activity
 
 from flock.core.context.context import FlockContext
 from flock.core.context.context_vars import FLOCK_CURRENT_AGENT, FLOCK_MODEL
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_registry import get_registry
-from flock.core.flock_router import HandOffRequest
+from flock.core.registry import get_registry
+
+# HandOffRequest removed - using agent.next_agent directly
 from flock.core.logging.logging import get_logger
 from flock.core.util.input_resolver import resolve_inputs
 
 logger = get_logger("activities")
 tracer = trace.get_tracer(__name__)
 
+def apply_handoff_strategy(previous_agent_output:str, next_agent_input:str, previous_agent_handoff_strategy:str, previous_agent_handoff_map:dict[str, str]) -> str:
+    if previous_agent_handoff_strategy == "append":
+        return next_agent_input + previous_agent_output
+    elif previous_agent_handoff_strategy == "override":
+        return previous_agent_output
+    elif previous_agent_handoff_strategy == "static":
+        return next_agent_input
+    elif previous_agent_handoff_strategy == "map":
+        for key, value in previous_agent_handoff_map.items():
+            next_agent_input = next_agent_input.replace(key, value)
+        return next_agent_input
+    raise NotImplementedError
+
 
 @activity.defn
 async def run_agent(context: FlockContext) -> dict:
@@ -29,6 +42,9 @@ async def run_agent(context: FlockContext) -> dict:
         registry = get_registry()
 
         previous_agent_name = ""
+        previous_agent_output = ""
+        previous_agent_handoff_strategy = ""
+        previous_agent_handoff_map = {}
         if isinstance(context, dict):
             context = FlockContext.from_dict(context)
         current_agent_name = context.get_variable(FLOCK_CURRENT_AGENT)
@@ -53,8 +69,14 @@ async def run_agent(context: FlockContext) -> dict:
                 iter_span.set_attribute("agent.name", agent.name)
                 agent.context = context
                 # Resolve inputs for the agent.
+                # Gets values from context, previous agent output, and handoff strategy.
                 agent_inputs = resolve_inputs(
-                    agent.input, context, previous_agent_name
+                    agent.input,
+                    context,
+                    previous_agent_name,
+                    previous_agent_output,
+                    previous_agent_handoff_strategy,
+                    previous_agent_handoff_map
                 )
                 iter_span.add_event(
                     "resolved inputs", attributes={"inputs": str(agent_inputs)}
@@ -78,72 +100,44 @@ async def run_agent(context: FlockContext) -> dict:
                         exec_span.record_exception(e)
                         raise
 
-                # Determine the next agent using the handoff router if available
-                handoff_data = HandOffRequest()
+                # Determine the next agent using routing component if available
+                next_agent_name = None
 
-                if agent.handoff_router:
+                if agent.router:
                     logger.info(
-                        f"Using handoff router: {agent.handoff_router.__class__.__name__}",
+                        f"Using router: {agent.router.__class__.__name__}",
                         agent=agent.name,
                     )
                     try:
-                        # Route to the next agent
-                        handoff_data = await agent.handoff_router.route(
+                        # Route to the next agent using new routing component
+                        next_agent_name = await agent.router.determine_next_step(
                             agent, result, context
                         )
 
-                        if callable(handoff_data):
-                            logger.debug(
-                                "Executing handoff function", agent=agent.name
-                            )
-                            try:
-                                handoff_data = handoff_data(context, result)
-                                if isinstance(
-                                    handoff_data.next_agent, FlockAgent
-                                ):
-                                    handoff_data.next_agent = (
-                                        handoff_data.next_agent.name
-                                    )
-                            except Exception as e:
-                                logger.error(
-                                    "Handoff function error {} {}",
-                                    agent=agent.name,
-                                    error=str(e),
-                                )
-                                iter_span.record_exception(e)
-                                return {"error": f"Handoff function error: {e}"}
-                        elif isinstance(handoff_data.next_agent, FlockAgent):
-                            handoff_data.next_agent = (
-                                handoff_data.next_agent.name
-                            )
+                        # Set next_agent on the agent instance
+                        agent.next_agent = next_agent_name
 
-                        if not handoff_data.next_agent:
-                            logger.info(
-                                "Router found no suitable next agent",
-                                agent=agent.name,
-                            )
-                            context.record(
-                                agent.name,
-                                result,
-                                timestamp=datetime.now().isoformat(),
-                                hand_off=None,
-                                called_from=previous_agent_name,
-                            )
-                            logger.info("Completing chain", agent=agent.name)
-                            iter_span.add_event("chain completed")
-                            return result
                     except Exception as e:
                         logger.error(
-                            "Router error {} {}",
-                            agent.name,
-                            str(e),
+                            f"Router error: {e}",
+                            agent=agent.name,
+                            error=str(e),
                         )
                         iter_span.record_exception(e)
                         return {"error": f"Router error: {e}"}
                 else:
-                    # No router, so no handoff
+                    # Check if next_agent was set directly by user
+                    next_agent_name = agent.next_agent
+                    if callable(next_agent_name):
+                        try:
+                            next_agent_name = next_agent_name(context, result)
+                        except Exception as e:
+                            logger.error(f"next_agent callable error: {e}")
+                            return {"error": f"next_agent callable error: {e}"}
+
+                if not next_agent_name:
                     logger.info(
-                        "No handoff router defined, completing chain",
+                        "No next agent found, completing chain",
                         agent=agent.name,
                     )
                     context.record(
@@ -161,53 +155,34 @@ async def run_agent(context: FlockContext) -> dict:
                     agent.name,
                     result,
                     timestamp=datetime.now().isoformat(),
-                    hand_off=handoff_data.model_dump(),
+                    hand_off={"next_agent": next_agent_name} if next_agent_name else None,
                     called_from=previous_agent_name,
                 )
+                # Remember the current agent's details for the next iteration.
                 previous_agent_name = agent.name
                 previous_agent_output = agent.output
-                if handoff_data.override_context:
-                    context.update(handoff_data.override_context)
+                previous_agent_handoff_strategy = agent.config.handoff_strategy
+                previous_agent_handoff_map = agent.config.handoff_map
 
-                # Prepare the next agent.
+                # Activate the next agent.
                 try:
-                    agent = registry.get_agent(handoff_data.next_agent)
-                    if handoff_data.output_to_input_merge_strategy == "add":
-                        agent.input = previous_agent_output + ", " + agent.input
-
-                    if handoff_data.add_input_fields:
-                        for field in handoff_data.add_input_fields:
-                            agent.input = field + ", " + agent.input
-
-                    if handoff_data.add_output_fields:
-                        for field in handoff_data.add_output_fields:
-                            agent.output = field + ", " + agent.output
-
-                    if handoff_data.add_description:
-                        if agent.description:
-                            agent.description = (
-                                agent.description
-                                + "\n"
-                                + handoff_data.add_description
-                            )
-                        else:
-                            agent.description = handoff_data.add_description
-
-                    agent.resolve_callables(context=context)
+                    agent = registry.get_agent(next_agent_name)
                     if not agent:
                         logger.error(
                             "Next agent not found",
-                            agent=handoff_data.next_agent,
+                            agent=next_agent_name,
                         )
                         iter_span.record_exception(
                             Exception(
-                                f"Next agent '{handoff_data.next_agent}' not found"
+                                f"Next agent '{next_agent_name}' not found"
                             )
                         )
                         return {
-                            "error": f"Next agent '{handoff_data.next_agent}' not found."
+                            "error": f"Next agent '{next_agent_name}' not found."
                         }
 
+                    agent.resolve_callables(context=context)
+
                     context.set_variable(FLOCK_CURRENT_AGENT, agent.name)
 
                     logger.info("Handing off to next agent", next=agent.name)