flock-core 0.3.5__py3-none-any.whl → 0.3.8__py3-none-any.whl

flock/routers/llm/llm_router.py

@@ -0,0 +1,363 @@
+"""LLM-based router implementation for the Flock framework."""
+
+import json
+from typing import Any
+
+import litellm
+
+from flock.core.context.context import FlockContext
+from flock.core.flock_agent import FlockAgent
+from flock.core.flock_router import (
+    FlockRouter,
+    FlockRouterConfig,
+    HandOffRequest,
+)
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("llm_router")
+
+
+class LLMRouterConfig(FlockRouterConfig):
+    """Configuration for the LLM router.
+
+    This class extends FlockRouterConfig with parameters specific to the LLM router.
+    """
+
+    temperature: float = 0.2
+    max_tokens: int = 500
+    confidence_threshold: float = 0.5
+    prompt: str = ""
+
+
+class LLMRouter(FlockRouter):
+    """Router that uses an LLM to determine the next agent in a workflow.
+
+    This class is responsible for:
+    1. Analyzing available agents in the registry
+    2. Using an LLM to score each agent's suitability as the next step
+    3. Selecting the highest-scoring agent
+    4. Creating a HandOff object with the selected agent
+    """
+
+    def __init__(
+        self,
+        name: str = "llm_router",
+        config: LLMRouterConfig | None = None,
+    ):
+        """Initialize the LLMRouter.
+
+        Args:
+            registry: The agent registry containing all available agents
+            name: The name of the router
+            config: The router configuration
+        """
+        logger.info(f"Initializing LLM Router '{name}'")
+        super().__init__(name=name, config=config or LLMRouterConfig(name=name))
+        logger.debug(
+            "LLM Router configuration",
+            temperature=self.config.temperature,
+            max_tokens=self.config.max_tokens,
+        )
+
+    async def route(
+        self,
+        current_agent: FlockAgent,
+        result: dict[str, Any],
+        context: FlockContext,
+    ) -> HandOffRequest:
+        """Determine the next agent to hand off to based on the current agent's output.
+
+        Args:
+            current_agent: The agent that just completed execution
+            result: The output from the current agent
+            context: The global execution context
+
+        Returns:
+            A HandOff object containing the next agent and input data
+        """
+        logger.info(
+            f"Routing from agent '{current_agent.name}'",
+            current_agent=current_agent.name,
+        )
+        logger.debug("Current agent result", result=result)
+
+        agent_definitions = context.agent_definitions
+        # Get all available agents from the registry
+        available_agents = self._get_available_agents(
+            agent_definitions, current_agent.name
+        )
+        logger.debug(
+            "Available agents for routing",
+            count=len(available_agents),
+            agents=[a.agent_data["name"] for a in available_agents],
+        )
+
+        if not available_agents:
+            logger.warning(
+                "No available agents for routing",
+                current_agent=current_agent.name,
+            )
+            return HandOffRequest(
+                next_agent="", override_next_agent={}, override_context=None
+            )
+
+        # Use LLM to determine the best next agent
+        next_agent_name, score = await self._select_next_agent(
+            current_agent, result, available_agents
+        )
+        logger.info(
+            "Agent selection result",
+            next_agent=next_agent_name,
+            score=score,
+        )
+
+        if not next_agent_name or score < self.config.confidence_threshold:
+            logger.warning(
+                "No suitable next agent found",
+                best_score=score,
+            )
+            return HandOffRequest(
+                next_agent="", override_next_agent={}, override_context=None
+            )
+
+        # Get the next agent from the registry
+        next_agent = agent_definitions.get(next_agent_name)
+        if not next_agent:
+            logger.error(
+                "Selected agent not found in registry",
+                agent_name=next_agent_name,
+            )
+            return HandOffRequest(
+                next_agent="", override_next_agent={}, override_context=None
+            )
+
+        # Create input for the next agent
+
+        logger.success(
+            f"Successfully routed to agent '{next_agent_name}'",
+            score=score,
+            from_agent=current_agent.name,
+        )
+        return HandOffRequest(
+            next_agent=next_agent_name,
+            hand_off_mode="add",
+            override_next_agent=None,
+            override_context=None,
+        )
+
+    def _get_available_agents(
+        self, agent_definitions: dict[str, Any], current_agent_name: str
+    ) -> list[FlockAgent]:
+        """Get all available agents except the current one.
+
+        Args:
+            current_agent_name: Name of the current agent to exclude
+
+        Returns:
+            List of available agents
+        """
+        logger.debug(
+            "Getting available agents",
+            total_agents=len(agent_definitions),
+            current_agent=current_agent_name,
+        )
+        agents = []
+        for agent in agent_definitions:
+            if agent != current_agent_name:
+                agents.append(agent_definitions.get(agent))
+        return agents
+
+    async def _select_next_agent(
+        self,
+        current_agent: FlockAgent,
+        result: dict[str, Any],
+        available_agents: list[FlockAgent],
+    ) -> tuple[str, float]:
+        """Use an LLM to select the best next agent.
+
+        Args:
+            current_agent: The agent that just completed execution
+            result: The output from the current agent
+            available_agents: List of available agents to choose from
+
+        Returns:
+            Tuple of (selected_agent_name, confidence_score)
+        """
+        logger.debug(
+            "Selecting next agent",
+            current_agent=current_agent.name,
+            available_count=len(available_agents),
+        )
+
+        # Prepare the prompt for the LLM
+        prompt = self._create_selection_prompt(
+            current_agent, result, available_agents
+        )
+        logger.debug("Generated selection prompt", prompt_length=len(prompt))
+
+        try:
+            logger.info(
+                "Calling LLM for agent selection",
+                model=current_agent.model,
+                temperature=self.config.temperature,
+            )
+            # Call the LLM to get the next agent
+            response = await litellm.acompletion(
+                model=current_agent.model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=self.config.temperature
+                if isinstance(self.config, LLMRouterConfig)
+                else 0.2,
+                max_tokens=self.config.max_tokens
+                if isinstance(self.config, LLMRouterConfig)
+                else 500,
+            )
+
+            content = response.choices[0].message.content
+            # Parse the response to get the agent name and score
+            try:
+                # extract the json object from the response
+                content = content.split("```json")[1].split("```")[0]
+                data = json.loads(content)
+                next_agent = data.get("next_agent", "")
+                score = float(data.get("score", 0))
+                reasoning = data.get("reasoning", "")
+                logger.info(
+                    "Successfully parsed LLM response",
+                    next_agent=next_agent,
+                    score=score,
+                    reasoning=reasoning,
+                )
+                return next_agent, score
+            except (json.JSONDecodeError, ValueError) as e:
+                logger.error(
+                    "Failed to parse LLM response",
+                    error=str(e),
+                    raw_response=content,
+                )
+                logger.debug("Attempting fallback parsing")
+
+                # Fallback: try to extract the agent name from the text
+                for agent in available_agents:
+                    if agent.agent_data["name"] in content:
+                        logger.info(
+                            "Found agent name in response using fallback",
+                            agent=agent.agent_data["name"],
+                        )
+                        return agent.agent_data[
+                            "name"
+                        ], 0.6  # Default score for fallback
+
+                return "", 0.0
+
+        except Exception as e:
+            logger.error(
+                "Error calling LLM for agent selection",
+                error=str(e),
+                current_agent=current_agent.name,
+            )
+            return "", 0.0
+
+    def _create_selection_prompt(
+        self,
+        current_agent: FlockAgent,
+        result: dict[str, Any],
+        available_agents: list[FlockAgent],
+    ) -> str:
+        """Create a prompt for the LLM to select the next agent.
+
+        Args:
+            current_agent: The agent that just completed execution
+            result: The output from the current agent
+            available_agents: List of available agents to choose from
+
+        Returns:
+            Prompt string for the LLM
+        """
+        # Format the current agent's output
+        result_str = json.dumps(result, indent=2)
+
+        # Format the available agents' information
+        agents_info = []
+        for agent in available_agents:
+            agent_info = {
+                "name": agent.agent_data["name"],
+                "description": agent.agent_data["description"]
+                if agent.agent_data["description"]
+                else "",
+                "input": agent.agent_data["input"],
+                "output": agent.agent_data["output"],
+            }
+            agents_info.append(agent_info)
+
+        agents_str = json.dumps(agents_info, indent=2)
+
+        # Create the prompt
+        if self.config.prompt:
+            prompt = self.config.prompt
+        else:
+            prompt = f"""
+You are a workflow router that determines the next agent to execute in a multi-agent system.
+
+CURRENT AGENT:
+Name: {current_agent.name}
+Description: {current_agent.description}
+Input: {current_agent.input}
+Output: {current_agent.output}
+
+CURRENT AGENT'S OUTPUT:
+{result_str}
+
+AVAILABLE AGENTS:
+{agents_str}
+
+Based on the current agent's output and the available agents, determine which agent should be executed next.
+Consider the following:
+1. Which agent's input requirements best match the current agent's output?
+2. Which agent's purpose and description make it the most logical next step?
+3. Which agent would provide the most value in continuing the workflow?
+
+Respond with a JSON object containing:
+1. "next_agent": The name of the selected agent
+2. "score": A confidence score between 0 and 1 indicating how suitable this agent is
+3. "reasoning": A brief explanation of why this agent was selected
+
+If no agent is suitable, set "next_agent" to an empty string and "score" to 0.
+
+JSON Response:
+"""
+        return prompt
+
+    def _create_next_input(
+        self,
+        current_agent: FlockAgent,
+        result: dict[str, Any],
+        next_agent: FlockAgent,
+    ) -> dict[str, Any]:
+        """Create the input for the next agent, including the previous agent's output.
+
+        Args:
+            current_agent: The agent that just completed execution
+            result: The output from the current agent
+            next_agent: The next agent to execute
+
+        Returns:
+            Input dictionary for the next agent
+        """
+        # Start with an empty input
+        next_input = {}
+
+        # Add a special field for the previous agent's output
+        next_input["previous_agent_output"] = {
+            "agent_name": current_agent.name,
+            "result": result,
+        }
+
+        # Try to map the current agent's output to the next agent's input
+        # This is a simple implementation that could be enhanced with more sophisticated mapping
+        for key in result:
+            # If the next agent expects this key, add it directly
+            if key in next_agent.input:
+                next_input[key] = result[key]
+
+        return next_input

flock/workflow/activities.py

@@ -7,7 +7,8 @@ from temporalio import activity
 
 from flock.core.context.context import FlockContext
 from flock.core.context.context_vars import FLOCK_CURRENT_AGENT
-from flock.core.flock_agent import FlockAgent, HandOff
+from flock.core.flock_agent import FlockAgent
+from flock.core.flock_router import HandOffRequest
 from flock.core.logging.logging import get_logger
 from flock.core.registry.agent_registry import Registry
 from flock.core.util.input_resolver import resolve_inputs
@@ -74,49 +75,83 @@ async def run_agent(context: FlockContext) -> dict:
                         exec_span.record_exception(e)
                         raise
 
-                # If there is no handoff, record the result and finish.
-                if not agent.hand_off:
-                    context.record(
-                        agent.name,
-                        result,
-                        timestamp=datetime.now().isoformat(),
-                        hand_off=None,
-                        called_from=previous_agent_name,
-                    )
+                # Determine the next agent using the handoff router if available
+                handoff_data = HandOffRequest()
+
+                if agent.handoff_router:
                     logger.info(
-                        "No handoff defined, completing chain", agent=agent.name
+                        f"Using handoff router: {agent.handoff_router.__class__.__name__}",
+                        agent=agent.name,
                     )
-                    iter_span.add_event("chain completed")
-                    return result
-
-                # Determine the next agent.
-                handoff_data = HandOff()
-                if callable(agent.hand_off):
-                    logger.debug("Executing handoff function", agent=agent.name)
                     try:
-                        handoff_data = agent.hand_off(context, result)
-                        if isinstance(handoff_data.next_agent, FlockAgent):
+                        # Route to the next agent
+                        handoff_data = await agent.handoff_router.route(
+                            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
                             )
+
+                        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(
-                            "Handoff function error",
-                            agent=agent.name,
-                            error=str(e),
+                            "Router error {} {}",
+                            agent.name,
+                            str(e),
                         )
                         iter_span.record_exception(e)
-                        return {"error": f"Handoff function error: {e}"}
-                elif isinstance(agent.hand_off, str | FlockAgent):
-                    handoff_data.next_agent = (
-                        agent.hand_off
-                        if isinstance(agent.hand_off, str)
-                        else agent.hand_off.name
-                    )
+                        return {"error": f"Router error: {e}"}
                 else:
-                    logger.error("Unsupported hand_off type", agent=agent.name)
-                    iter_span.add_event("unsupported hand_off type")
-                    return {"error": "Unsupported hand_off type."}
+                    # No router, so no handoff
+                    logger.info(
+                        "No handoff router defined, 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
 
                 # Record the agent run in the context.
                 context.record(
@@ -127,10 +162,15 @@ async def run_agent(context: FlockContext) -> dict:
                     called_from=previous_agent_name,
                 )
                 previous_agent_name = agent.name
+                previous_agent_output = agent.output
+                if handoff_data.override_context:
+                    context.update(handoff_data.override_context)
 
                 # Prepare the next agent.
                 try:
                     agent = registry.get_agent(handoff_data.next_agent)
+                    if handoff_data.hand_off_mode == "add":
+                        agent.input = previous_agent_output + ", " + agent.input
                     agent.resolve_callables(context=context)
                     if not agent:
                         logger.error(
@@ -147,6 +187,7 @@ async def run_agent(context: FlockContext) -> dict:
                         }
 
                     context.set_variable(FLOCK_CURRENT_AGENT, agent.name)
+
                     logger.info("Handing off to next agent", next=agent.name)
                     iter_span.set_attribute("next.agent", agent.name)
                 except Exception as e:

{flock_core-0.3.5.dist-info → flock_core-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.5
+Version: 0.3.8
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.3.5.dist-info → flock_core-0.3.8.dist-info}/RECORD

@@ -8,15 +8,16 @@ flock/cli/load_examples.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 flock/cli/load_flock.py,sha256=3JdECvt5X7uyOG2vZS3-Zk5C5SI_84_QZjcsB3oJmfA,932
 flock/cli/load_release_notes.py,sha256=qFcgUrMddAE_TP6x1P-6ZywTUjTknfhTDW5LTxtg1yk,599
 flock/cli/settings.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
-flock/cli/assets/release_notes.md,sha256=K-upUm5vuUuRSSU2FkMdgDfai_YlDk_vTCp0s4s2WO0,3419
+flock/cli/assets/release_notes.md,sha256=-RuE-G9Sn8z1LWEdr9iqjuQN7N1K_JMaCzHYoyLR42U,4793
 flock/core/__init__.py,sha256=mPlvKc0SxC2qCvSlgYeP_7EyV8ptmdn24NO8mlQoCSo,559
 flock/core/flock.py,sha256=1LPMblsvT90Na35LXx0w3Us66yIaTzsokL7lF5fsVX8,19228
-flock/core/flock_agent.py,sha256=RzKX0GRrRJz16YbQFheMo8TqJPXOZSHWNloTbp35zwI,12229
+flock/core/flock_agent.py,sha256=LjSuAYRFh4UWV8Z4_mguMme2GnMQwteNFyion4Memt8,11705
 flock/core/flock_api.py,sha256=SKQVKgFCaNCqHtwvIcksnpqG6ajHodVhs3oaKUw-d8c,7192
 flock/core/flock_evaluator.py,sha256=j7riJj_KsWoBnKmLiGp-U0CRhxDyJbgEdLGN26tfKm8,1588
-flock/core/flock_factory.py,sha256=vyDq0eyFT4MyE_n2JyNU7YaFx2ljmjSDmZ07OIsmIOE,2694
-flock/core/flock_module.py,sha256=VWFlBiY2RHZLTlGYfcchuT41M3m_JrZcmzw07u7KayM,2581
-flock/core/context/context.py,sha256=fb7SsGAXmhQ1CvHV3_GihGiJG-4oLJ_DcexJ8vsrbHM,6371
+flock/core/flock_factory.py,sha256=xTz2VqcLjaHn60b3Oaz8JCJdcIQra0vc5NHqh3Dy44s,2617
+flock/core/flock_module.py,sha256=3DmxOc39gQS-tiJcgUCjMaLr8QDDJR4acV_M76Xcf6I,2602
+flock/core/flock_router.py,sha256=A5GaxcGvtiFlRLHBTW7okh5RDm3BdKam2uXvRHRaj7k,2187
+flock/core/context/context.py,sha256=AW0qKIAkgZucVroGsulrPVPc4WmWuqWIrVPHf2qaOLI,6380
 flock/core/context/context_manager.py,sha256=qMySVny_dbTNLh21RHK_YT0mNKIOrqJDZpi9ZVdBsxU,1103
 flock/core/context/context_vars.py,sha256=0Hn6fM2iNc0_jIIU0B7KX-K2o8qXqtZ5EYtwujETQ7U,272
 flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjaygl_Db0M8ao,952
@@ -37,15 +38,16 @@ flock/core/logging/telemetry_exporter/sqlite_exporter.py,sha256=CDsiMb9QcqeXelZ6
 flock/core/mixin/dspy_integration.py,sha256=P5G4Y04nl5hFwFbJXCkQ-0TMR1L4skLL2IM_FlUjH_c,8364
 flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgweoxI,5121
 flock/core/registry/agent_registry.py,sha256=TUClh9e3eA6YzZC1CMTlsTPvQeqb9jYHewi-zPpcWM8,4987
+flock/core/serialization/secure_serializer.py,sha256=n5-zRvvXddgJv1FFHsaQ2wuYdL3WUSGPvG_LGaffEJo,6144
+flock/core/serialization/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
 flock/core/tools/basic_tools.py,sha256=fI9r81_ktRiRhNLwT-jSJ9rkjl28LC1ZfL-njnno2iw,4761
 flock/core/tools/dev_tools/github.py,sha256=a2OTPXS7kWOVA4zrZHynQDcsmEi4Pac5MfSjQOLePzA,5308
 flock/core/util/cli_helper.py,sha256=IOl9r4cz_MJv_Bp5R8dhHX8f-unAqA9vDS6-0E90Vzk,49813
 flock/core/util/hydrator.py,sha256=6qNwOwCZB7r6y25BZ--0PGofrAlfMaXbDKFQeP5NLts,11196
 flock/core/util/input_resolver.py,sha256=g9vDPdY4OH-G7qjas5ksGEHueokHGFPMoLOvC-ngeLo,5984
-flock/core/util/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
 flock/evaluators/declarative/declarative_evaluator.py,sha256=f8ldgZZp94zC4CoGzBufKvbvtckCGBe9EHTOoAZfZK0,1695
 flock/evaluators/natural_language/natural_language_evaluator.py,sha256=6nVEeh8_uwv_h-d3FWlA0GbzDzRtdhvxCGKirHtyvOU,2012
-flock/evaluators/zep/zep_evaluator.py,sha256=hEHQdgIwGsbC4ci9RvtdA2k7f4M0yznIok4v4XltNwg,1885
+flock/evaluators/zep/zep_evaluator.py,sha256=9NOELl7JAuUcx_FQrxY6b-_vN3MjwDyW7ZppPIGeCFc,1954
 flock/modules/callback/callback_module.py,sha256=hCCw-HNYjK4aHnUQfvw26ZP1Q_jdlKb9kDh3BHzbCQA,2916
 flock/modules/memory/memory_module.py,sha256=2grdmvw7FJWZvz0IjgASbDPCfyS1w4gWkRzOWtK7BFM,8214
 flock/modules/memory/memory_parser.py,sha256=2S7CmVEsm22gD7-MiFj4318FTg8wd_jB-RKMwXI14WM,4369
@@ -55,6 +57,14 @@ flock/modules/performance/metrics_module.py,sha256=K5z5bizIjA4ZEUjBk5ShwTR9ZElR-
 flock/modules/zep/zep_module.py,sha256=BIJ5K-hg2bLeJmGKoDcVY1rVN7_0yYETiSaVrO-gtMI,5830
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
 flock/platform/jaeger_install.py,sha256=MyOMJQx4TQSMYvdUJxfiGSo3YCtsfkbNXcAcQ9bjETA,2898
+flock/routers/__init__.py,sha256=w9uL34Auuo26-q_EGlE8Z9iHsw6S8qutTAH_ZI7pn7M,39
+flock/routers/agent/__init__.py,sha256=0ZOYpR8BMnR5iCGfcUiv99g7aT_g13xvm2Shl-XzybY,65
+flock/routers/agent/agent_router.py,sha256=9s3AwcBqpyhpPXOTqyMSVtS8Bcme1RDdqSUfWIqEBfc,8139
+flock/routers/agent/handoff_agent.py,sha256=p-0XEPXIyv1T3DGAhhXg2SYXmrwEaJ5pnuLgRSvbiZg,1903
+flock/routers/default/__init__.py,sha256=DOatGX_aE2DWvf55a0Tv7qDK05QFD-hL3sm7g58hmLU,61
+flock/routers/default/default_router.py,sha256=D9TCAAeNfzt3Se6QduGO2TmZ6038XlQLV6Y1u5IGI-0,2232
+flock/routers/llm/__init__.py,sha256=OV89ebq8RPWZwCJTS2_P46Q0yKD_03rwq_fBOsETd08,63
+flock/routers/llm/llm_router.py,sha256=3WXUK2TqZENYXSFb7o_WtpONq0SsebaZZpytCRr1daw,12217
 flock/themes/3024-day.toml,sha256=uOVHqEzSyHx0WlUk3D0lne4RBsNBAPCTy3C58yU7kEY,667
 flock/themes/3024-night.toml,sha256=qsXUwd6ZYz6J-R129_Ao2TKlvvK60svhZJJjB5c8Tfo,1667
 flock/themes/aardvark-blue.toml,sha256=5ZgsxP3pWLPN3yJ2Wd9ErCo7fy_VJpIfje4kriDKlqo,1667
@@ -392,12 +402,12 @@ flock/themes/zenburned.toml,sha256=UEmquBbcAO3Zj652XKUwCsNoC2iQSlIh-q5c6DH-7Kc,1
 flock/themes/zenwritten-dark.toml,sha256=To5l6520_3UqAGiEumpzGWsHhXxqu9ThrMildXKgIO0,1669
 flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolUYolmE,1666
 flock/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/workflow/activities.py,sha256=2zcYyDoCuYs9oQbnhLjCzBUdEi7d5IEIemKJ7TV_B8w,6932
+flock/workflow/activities.py,sha256=PqUc1jecg-7qq4KQr0Gr2XLNCABZ79fvD1MqazT--YU,8866
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.3.5.dist-info/METADATA,sha256=MBhu8EjW-aFe1MCkusE0AiL4tE7Pv6kdh1czCCbqVLU,20494
-flock_core-0.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.3.5.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.3.5.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.3.5.dist-info/RECORD,,
+flock_core-0.3.8.dist-info/METADATA,sha256=0ImaV46N5uSNlZPP4kF2q-pjfY3nsLLHzDvicvv7_gA,20494
+flock_core-0.3.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.8.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.8.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.8.dist-info/RECORD,,