flock-core 0.4.527__py3-none-any.whl → 0.5.0b0__py3-none-any.whl

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

@@ -473,7 +473,7 @@ async def chat_send_shared(
         if frozen_chat_cfg.history_key: run_input[frozen_chat_cfg.history_key] = [h["text"] for h in history if h.get("role") == "user" or h.get("role") == "bot"]
 
         try:
-            result_dict = await flock_inst.run_async(start_agent=bot_agent, input=run_input, box_result=False)
+            result_dict = await flock_inst.run_async(agent=bot_agent, input=run_input, box_result=False)
             if frozen_chat_cfg.response_key:
                 bot_text = str(result_dict.get(frozen_chat_cfg.response_key, result_dict))
             else:

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/webapp/app/services/flock_service.py

@@ -281,7 +281,7 @@ async def run_current_flock_service(
         logger.info(f"Executing agent '{start_agent_name}' from flock '{current_flock.name}' using app_state.")
         # Direct execution using the flock from app_state
         result = await current_flock.run_async(
-            start_agent=start_agent_name, input=inputs, box_result=False
+            agent=start_agent_name, input=inputs, box_result=False
         )
         # Store run details using the run_store from app_state
         if hasattr(run_store, "add_run_details"): # Check if RunStore has this method

flock/webapp/app/services/sharing_store.py

@@ -304,6 +304,7 @@ class SQLiteSharedLinkStore(SharedLinkStoreInterface):
             logger.error(f"SQLite error saving feedback {record.feedback_id}: {e}", exc_info=True)
             raise
 
+
 # ---------------------------------------------------------------------------
 # Azure Table + Blob implementation
 # ---------------------------------------------------------------------------

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
+
+# HandOffRequest removed - using agent.next_agent directly
 from flock.core.logging.logging import get_logger
+from flock.core.registry import get_registry
 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)
@@ -38,7 +54,7 @@ async def run_agent(context: FlockContext) -> dict:
         agent = registry.get_agent(current_agent_name)
         if agent.model is None or agent.evaluator.config.model is None:
             agent.set_model(context.get_variable(FLOCK_MODEL))
-        agent.resolve_callables(context=context)
+
         if not agent:
             logger.error("Agent not found", agent=current_agent_name)
             span.record_exception(
@@ -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)}
@@ -69,6 +91,13 @@ async def run_agent(context: FlockContext) -> dict:
                         logger.debug(
                             "Agent execution completed", agent=agent.name
                         )
+                        context.record(
+                            agent.name,
+                            result,
+                            timestamp=datetime.now().isoformat(),
+                            hand_off=None,
+                            called_from=previous_agent_name,
+                        )
                     except Exception as e:
                         logger.error(
                             "Agent execution failed",
@@ -78,81 +107,46 @@ 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(
-                        agent.name,
-                        result,
-                        timestamp=datetime.now().isoformat(),
-                        hand_off=None,
-                        called_from=previous_agent_name,
-                    )
                     iter_span.add_event("chain completed")
                     return result
 
@@ -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."
                         }
 
+
+
                     context.set_variable(FLOCK_CURRENT_AGENT, agent.name)
 
                     logger.info("Handing off to next agent", next=agent.name)

flock/workflow/agent_execution_activity.py

@@ -12,8 +12,8 @@ from temporalio import activity
 from flock.core.context.context import FlockContext
 from flock.core.context.context_vars import FLOCK_MODEL
 from flock.core.flock_agent import FlockAgent  # Import concrete class if needed
-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
 
@@ -133,22 +133,22 @@ async def determine_next_agent(
                 f"Agent '{current_agent_name}' not found for routing."
             )
 
-        if not agent.handoff_router:
+        if not agent.router:
             logger.info(
-                "No handoff router defined for agent", agent=current_agent_name
+                "No router defined for agent", agent=current_agent_name
             )
             span.add_event("no_router")
             return None  # Indicate no handoff
 
         logger.debug(
-            f"Using router {agent.handoff_router.__class__.__name__}",
+            f"Using router {agent.router.__class__.__name__}",
             agent=agent.name,
         )
         try:
             # Execute the routing logic
             handoff_data: (
                 HandOffRequest | Callable
-            ) = await agent.handoff_router.route(agent, result, context)
+            ) = await agent.router.route(agent, result, context)
 
             # Handle callable handoff functions - This is complex in distributed systems.
             # Consider if this pattern should be supported or if routing should always

flock/workflow/flock_workflow.py

@@ -7,7 +7,7 @@ from temporalio import workflow
 with workflow.unsafe.imports_passed_through():
     from flock.core.context.context import AgentDefinition, FlockContext
     from flock.core.context.context_vars import FLOCK_CURRENT_AGENT
-    from flock.core.flock_router import HandOffRequest
+    # HandOffRequest removed - using agent.next_agent directly
     from flock.core.logging.logging import get_logger
     from flock.workflow.agent_execution_activity import (
         determine_next_agent,