flock-core 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

flock/workflow/activities.py

@@ -1,12 +1,13 @@
-"""Defines Temporal activities for running a chain of agents."""
+"""Defines Temporal activities for running a chain of agents with logging and tracing."""
 
 from datetime import datetime
 
+from opentelemetry import trace
 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, HandoffBase
+from flock.core.flock_agent import FlockAgent, HandOff
 from flock.core.logging.formatters.base_formatter import FormatterOptions
 from flock.core.logging.formatters.formatter_factory import FormatterFactory
 from flock.core.logging.logging import get_logger
@@ -14,6 +15,7 @@ from flock.core.registry.agent_registry import Registry
 from flock.core.util.input_resolver import resolve_inputs
 
 logger = get_logger("activities")
+tracer = trace.get_tracer(__name__)
 
 
 @activity.defn
@@ -22,96 +24,152 @@ async def run_agent(
 ) -> dict:
     """Runs a chain of agents using the provided context.
 
-    The context contains:
-      - A state (e.g., "init_input", "current_agent", etc.),
-      - A history of agent runs.
-
-    Each agent uses the current value of the variable specified in its `input` attribute.
-    After each run, its output is merged into the context state.
-    The default handoff behavior is to fetch the next agent's input automatically from the context.
+    The context contains state, history, and agent definitions.
+    After each agent run, its output is merged into the context.
     """
-    registry = Registry()
-    previous_agent_name = ""
-    current_agent_name = context.get_variable(FLOCK_CURRENT_AGENT)
-    handoff_data: HandoffBase = None
-
-    logger.info("Starting agent chain", initial_agent=current_agent_name)
-
-    agent = registry.get_agent(current_agent_name)
-    if not agent:
-        logger.error("Agent not found", agent=current_agent_name)
-        return {"error": f"Agent '{current_agent_name}' not found."}
-
-    while agent:
-        # Get the inputs for the agent
-
-        agent_inputs = resolve_inputs(agent.input, context, previous_agent_name)
-
-        # Execute the agent
-        logger.info("Executing agent")
-        result = await agent.run(agent_inputs)
-        logger.debug("Agent execution completed")
-
-        if output_formatter:
-            formatter = FormatterFactory.create_formatter(output_formatter)
-            formatter.display(
-                result, agent.name, output_formatter.wait_for_input
+    # Start a top-level span for the entire run_agent activity.
+    with tracer.start_as_current_span("run_agent") as span:
+        registry = Registry()
+        previous_agent_name = ""
+        if isinstance(context, dict):
+            context = FlockContext.from_dict(context)
+        current_agent_name = context.get_variable(FLOCK_CURRENT_AGENT)
+        span.set_attribute("initial.agent", current_agent_name)
+        logger.info("Starting agent chain", initial_agent=current_agent_name)
+
+        agent = registry.get_agent(current_agent_name)
+        agent.resolve_callables(context=context)
+        if not agent:
+            logger.error("Agent not found", agent=current_agent_name)
+            span.record_exception(
+                Exception(f"Agent '{current_agent_name}' not found")
             )
+            return {"error": f"Agent '{current_agent_name}' not found."}
 
-        # If no handoff is defined, return the result
-        if not agent.hand_off:
-            context.record(
-                agent.name,
-                result,
-                timestamp=datetime.now(),
-                hand_off=None,
-                called_from=previous_agent_name,
-            )
-            logger.info("No handoff defined, completing chain")
-            return result
-
-        # Determine the next agent
-        handoff_data = HandoffBase()
-        if callable(agent.hand_off):
-            logger.debug("Executing handoff function")
-            handoff_data = agent.hand_off(context, result)
-            if isinstance(handoff_data.next_agent, FlockAgent):
-                handoff_data.next_agent = handoff_data.next_agent.name
-
-        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
-            )
-        else:
-            logger.error("Unsupported hand_off type")
-            return {"error": "Unsupported hand_off type."}
-
-        context.record(
-            agent.name,
-            result,
-            timestamp=datetime.now().isoformat(),
-            hand_off=handoff_data,
-            called_from=previous_agent_name,
-        )
-        previous_agent_name = agent.name
-
-        # Update the current agent and prepare the next input automatically
-        try:
-            agent = registry.get_agent(handoff_data.next_agent)
-            if not agent:
-                logger.error(
-                    "Next agent not found", agent=handoff_data.next_agent
-                )
-                return {
-                    "error": f"Next agent '{handoff_data.next_agent}' not found."
-                }
+        # Loop over agents in the chain.
+        while agent:
+            # Create a nested span for this iteration.
+            with tracer.start_as_current_span("agent_iteration") as iter_span:
+                iter_span.set_attribute("agent.name", agent.name)
 
-            context.set_variable(FLOCK_CURRENT_AGENT, agent.name)
-            logger.info("Handing off to next agent", next=agent.name)
-        except Exception as e:
-            logger.error("Error during handoff", error=e)
-            return {"error": f"Error during handoff: {e}"}
+                # Resolve inputs for the agent.
+                agent_inputs = resolve_inputs(
+                    agent.input, context, previous_agent_name
+                )
+                iter_span.add_event(
+                    "resolved inputs", attributes={"inputs": str(agent_inputs)}
+                )
 
-    return context.get_variable("init_input")
+                # Execute the agent with its own span.
+                with tracer.start_as_current_span("execute_agent") as exec_span:
+                    logger.info("Executing agent", agent=agent.name)
+                    try:
+                        result = await agent.run(agent_inputs)
+                        exec_span.set_attribute("result", str(result))
+                        logger.debug(
+                            "Agent execution completed", agent=agent.name
+                        )
+                    except Exception as e:
+                        logger.error(
+                            "Agent execution failed",
+                            agent=agent.name,
+                            error=str(e),
+                        )
+                        exec_span.record_exception(e)
+                        raise
+
+                # Optionally display formatted output.
+                display_output = True
+                if agent.config:
+                    display_output = not agent.config.disable_output
+
+                if output_formatter and display_output:
+                    formatter = FormatterFactory.create_formatter(
+                        output_formatter
+                    )
+                    formatter.display(
+                        result, agent.name, output_formatter.wait_for_input
+                    )
+
+                # 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,
+                    )
+                    logger.info(
+                        "No handoff defined, completing chain", 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):
+                            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(agent.hand_off, str | FlockAgent):
+                    handoff_data.next_agent = (
+                        agent.hand_off
+                        if isinstance(agent.hand_off, str)
+                        else agent.hand_off.name
+                    )
+                else:
+                    logger.error("Unsupported hand_off type", agent=agent.name)
+                    iter_span.add_event("unsupported hand_off type")
+                    return {"error": "Unsupported hand_off type."}
+
+                # Record the agent run in the context.
+                context.record(
+                    agent.name,
+                    result,
+                    timestamp=datetime.now().isoformat(),
+                    hand_off=handoff_data,
+                    called_from=previous_agent_name,
+                )
+                previous_agent_name = agent.name
+
+                # Prepare the next agent.
+                try:
+                    agent = registry.get_agent(handoff_data.next_agent)
+                    agent.resolve_callables(context=context)
+                    if not agent:
+                        logger.error(
+                            "Next agent not found",
+                            agent=handoff_data.next_agent,
+                        )
+                        iter_span.record_exception(
+                            Exception(
+                                f"Next agent '{handoff_data.next_agent}' not found"
+                            )
+                        )
+                        return {
+                            "error": f"Next agent '{handoff_data.next_agent}' not found."
+                        }
+
+                    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:
+                    logger.error("Error during handoff", error=str(e))
+                    iter_span.record_exception(e)
+                    return {"error": f"Error during handoff: {e}"}
+
+        # If the loop exits unexpectedly, return the initial input.
+        return context.get_variable("init_input")

{flock_core-0.2.1.dist-info → flock_core-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.2.1
+Version: 0.2.3
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -14,6 +14,12 @@ Requires-Dist: dspy==2.5.42
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: msgpack>=1.1.0
+Requires-Dist: opentelemetry-api>=1.30.0
+Requires-Dist: opentelemetry-exporter-jaeger-proto-grpc>=1.21.0
+Requires-Dist: opentelemetry-exporter-jaeger>=1.21.0
+Requires-Dist: opentelemetry-exporter-otlp>=1.30.0
+Requires-Dist: opentelemetry-instrumentation-logging>=0.51b0
+Requires-Dist: opentelemetry-sdk>=1.30.0
 Requires-Dist: pydantic>=2.10.5
 Requires-Dist: python-box>=7.3.2
 Requires-Dist: rich>=13.9.4
@@ -30,7 +36,7 @@ Description-Content-Type: text/markdown
 
 <p align="center">
 <img src="docs/img/flock.png" width="600"><br>
-<h1 align="center">Flock</h1><br>
+<h1 align="center">Flock<br></h1><br>
 
 
 ## Overview
@@ -83,6 +89,10 @@ Flock is a framework for orchestrating LLM-powered agents. It leverages a **decl
 - **DSPy Integration:**  
   Flock leverages DSPy for managing LLM interactions. The framework constructs clean signature strings and updates field metadata so that DSPy can include detailed instructions and context for each agent call.
 
+
+<p align="center">
+<img src="docs/img/flock_cli.png" width="200"><br>
+
 ## Quick Start
 
 Below is a simple example of how to create and run an agent with Flock:
@@ -238,6 +248,30 @@ pip install flock-core[all-tools]
    uv build && uv pip install -e .
    ```
 
+Install Jaeger for telemetry
+```
+
+docker run -d --name jaeger \
+  -e COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
+  -p 5775:5775/udp \
+  -p 6831:6831/udp \
+  -p 6832:6832/udp \
+  -p 5778:5778 \
+  -p 16686:16686 \
+  -p 14268:14268 \
+  -p 14250:14250 \
+  -p 9411:9411 \
+  jaegertracing/all-in-one:1.41
+
+
+```
+
+or zipkin
+
+```
+docker run -d -p 9411:9411 openzipkin/zipkin
+
+```
 
 ## Contributing
 

{flock_core-0.2.1.dist-info → flock_core-0.2.3.dist-info}/RECORD

@@ -1,31 +1,31 @@
-flock/__init__.py,sha256=JeRpPR29wyqXe8El-Ug4v_Ibhf5GQm_i8yWMi0cUYz0,36
-flock/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/agents/batch_agent.py,sha256=TgSHSX1xv2CdaxP-XsaqWoZvaW1lDj4Xi3Cklr2H3wE,4946
-flock/agents/loop_agent.py,sha256=qoUun9Nl4ODClPXLY9jI3tdjC1t9DdBLouXJyyV_-5g,4264
-flock/agents/trigger_agent.py,sha256=ID82EobfqVh6b5oUOE2GimNoraHV_8vU9bh-52h0NI4,4222
-flock/agents/user_agent.py,sha256=2OJSUIxNDWRxoTqiVarxGtmaFdazm8tiQwI5biLbkBc,4704
-flock/core/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-flock/core/flock.py,sha256=F7hZWycq6IXPw1VNqhT1w6Wil3O4vQIkDZTDBmmILaw,8027
-flock/core/flock_agent.py,sha256=P6GCE5-d8DvGARwN5u2HFDsDOtTQB6aEASozJc09w3g,23662
-flock/core/context/context.py,sha256=yNsYHanXbo8EijBp4f3PiY0YCFcN9dSbmnLKhx3Q8Nw,7340
+flock/__init__.py,sha256=uJxXAxt0def69cccAAdLjBxQOFXVRO72RE82hJnODSw,108
+flock/config.py,sha256=hul_Vmgl8w5a_4YNfg3Mvll3iVEkjiR5At9D0WsVesw,1006
+flock/core/__init__.py,sha256=0Xq_txurlxxjKGXjRn6GNJusGTiBcd7zw2eF0L7JyuU,183
+flock/core/flock.py,sha256=Iw7Frmz2aZheApxi2KSjsX7gA8ZcemzXhfKXeQdtY0w,9438
+flock/core/flock_agent.py,sha256=59qQ7ohOy2lc1KjI6SV7IcrqYL86ofAhq32pZGgk6eA,27761
+flock/core/context/context.py,sha256=jH06w4C_O5CEL-YxjX_x_dmgLe9Rcllnn1Ebs0dvwaE,6171
 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=O_dgQ_HJPCp97ghdEoDSNDIiaYkogrUS0G2FfK04RRc,973
-flock/core/execution/temporal_executor.py,sha256=rHZPPzgqm6x3AYHOrleWUfEQcF1XpW-c0x4bAvMJCCQ,1727
+flock/core/execution/temporal_executor.py,sha256=ai6ikr9rEiN2Kc-208OalxtfqL_FTt_UaH6a--oEkJM,2010
 flock/core/logging/__init__.py,sha256=Q8hp9-1ilPIUIV0jLgJ3_cP7COrea32cVwL7dicPnlM,82
-flock/core/logging/logging.py,sha256=ny90ocZatLn-wHtpNrmMK2y1lPLqUpiw6kzWUj7C-Ao,4005
+flock/core/logging/logging.py,sha256=F-FDz9etBXmAIT-fjx3pUfvNXsckgR6ONCMaFZIc4Kw,4619
+flock/core/logging/telemetry.py,sha256=T2CRSiqOWvOsXe-WRsObkkOkrrd6z-BwEYLaBUU2AAM,4017
+flock/core/logging/trace_and_logged.py,sha256=h4YH8s0KjK4tiBdrEZdCLd4fDzMB5-NKwqzrtkWhQw4,1999
 flock/core/logging/formatters/base_formatter.py,sha256=CyG-X2NWq8sqEhFEO2aG7Mey5tVkIzoWiihW301_VIo,1023
 flock/core/logging/formatters/formatter_factory.py,sha256=hmH-NpCESHkioX0GBQ5CuQR4axyIXnSRWwAZCHylx6Q,1283
 flock/core/logging/formatters/pprint_formatter.py,sha256=2CZoMbfzJB9Xp9WaItxnXY3hfANMjDTXowk3ni6N-h4,565
 flock/core/logging/formatters/rich_formatters.py,sha256=h1FD0_cIdQBQ8P2x05XhgD1cmmP80IBNVT5jb3cAV9M,4776
 flock/core/logging/formatters/theme_builder.py,sha256=1RUEwPIDfCjwTapbK1liasA5SdukOn7YwbZ4H4j1WkI,17364
 flock/core/logging/formatters/themed_formatter.py,sha256=CbxmqUC7zkLzyIxngk-3dcpQ6vxPR6zaDNA2TAMitCI,16714
-flock/core/mixin/dspy_integration.py,sha256=f22SK4iF8I3h3HPyOTPa9iAb3RzsVFvCJC3vO5MHYko,6122
+flock/core/logging/telemetry_exporter/file_span.py,sha256=e4hr4D7tC9j4KT7JZBuZU0YxQCdHKADpXNeUNEwggN4,1294
+flock/core/logging/telemetry_exporter/sqllite_span.py,sha256=9bqxHt1mDQGyhKxA9dON5xDi_6FMOfBSdrU_zWV0xv4,2107
+flock/core/mixin/dspy_integration.py,sha256=oT5YfXxPhHkMCuwhXoppBAYBGePUAKse7KebGSM-bq0,6880
 flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgweoxI,5121
-flock/core/registry/agent_registry.py,sha256=VuuztTZXDwa2JIzIgY1EL3h-9T8_Vnk-eXI0CdjP5xM,2884
-flock/core/tools/basic_tools.py,sha256=0PnPBc4fvzTpGaAEaI2GI_oKiwlHXCXJnpRDHQEH-b0,8336
-flock/core/tools/dev_tools/github.py,sha256=9nXt0KxR5oVK1AH2TN1KL2QK8xGxFhkn-o8bB-S1GcE,6296
-flock/core/util/cli_helper.py,sha256=1PvqhnxlLy4C5BohqSzrR84BrDGyk0NGGCTXgrCU4FM,567
+flock/core/registry/agent_registry.py,sha256=QHdr3Cb-32PEdz8jFCIZSH9OlfpRwAJMtSRpHCWJDq4,4889
+flock/core/tools/basic_tools.py,sha256=nRc1bIz96z-WUTe_yYf9V6EfCPEncl_XnrpGdC7dEmo,8721
+flock/core/tools/dev_tools/github.py,sha256=6ya2_eN-qITV3b_pYP24jQC3X4oZbRY5GKh1AF-9Zic,6836
+flock/core/util/cli_helper.py,sha256=hXBXhTQizZILXiVeBFR6QdAsQm0Qj29ANHJRgiekwyw,859
 flock/core/util/input_resolver.py,sha256=OesGqX2Dld8myL9Qz04mmxLqoYqOSQC632pj1EMk9Yk,5456
 flock/core/util/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
 flock/themes/3024-day.toml,sha256=uOVHqEzSyHx0WlUk3D0lne4RBsNBAPCTy3C58yU7kEY,667
@@ -365,11 +365,11 @@ 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=IZM9wOJZWFUzT88nPdmtXkk288nc_FOZsyR2xhA2dWs,4302
+flock/workflow/activities.py,sha256=YEg-Gr8kzVsxWsmsZguIVhX2XwMRvhZ2OlnsJoG5g_A,7646
 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.2.1.dist-info/METADATA,sha256=ywzUx2LF6i23eC5SBOnfu0v8El_9Z2K0biPmqkjvWzg,10381
-flock_core-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.2.1.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.2.1.dist-info/RECORD,,
+flock_core-0.2.3.dist-info/METADATA,sha256=cgqdCwNfYyRzXuhttnph9L7L87YOolVUDh6PYRHCbJ4,11129
+flock_core-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.2.3.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.2.3.dist-info/RECORD,,

flock/agents/batch_agent.py

@@ -1,140 +0,0 @@
-import asyncio
-import uuid
-from typing import Any
-
-from pydantic import Field
-
-from flock.core.context.context import FlockContext
-from flock.core.flock_agent import FlockAgent
-
-
-class BatchAgent(FlockAgent):
-    """A DeclarativeAgent that processes an iterable input in batches.
-
-    Additional Attributes:
-      iter_input: The key in the FlockContext that holds the iterable (a list).
-      batch_site: The number of items per batch.
-
-    For each batch, the agent's input dictionary is built from the FlockContext with the
-    value for the iter_input key overridden by the current batch. The outputs across batches
-    are then aggregated.
-    """
-
-    iter_input: str = Field(
-        default="",
-        description="Key of the iterable input (must be a list in the FlockContext)",
-    )
-    batch_size: int = Field(
-        default=1, description="Batch size (number of items per batch)"
-    )
-
-    async def run(self, context: FlockContext) -> dict:
-        """Run the BatchAgent locally by partitioning the iterable and aggregating the results."""
-        try:
-            iterable = context.get_variable(self.iter_input)
-            if not isinstance(iterable, list):
-                error_msg = (
-                    f"Expected a list for key '{self.iter_input}' in context."
-                )
-                return {"error": error_msg}
-
-            # Partition the iterable into batches
-            batches: list[list[Any]] = [
-                iterable[i : i + self.batch_size]
-                for i in range(0, len(iterable), self.batch_size)
-            ]
-
-            # Process batches
-            tasks = []
-            for batch in batches:
-                tasks.append(
-                    self.evaluate(
-                        context, input_overrides={self.iter_input: batch}
-                    )
-                )
-
-            batch_results = await asyncio.gather(*tasks)
-
-            # Aggregate the outputs
-            output_keys = self._parse_keys(self.output)
-            aggregated = {key: [] for key in output_keys}
-            for res in batch_results:
-                for key in output_keys:
-                    aggregated[key].append(res.get(key))
-            aggregated["batch_results"] = batch_results
-            return aggregated
-
-        except Exception:
-            raise
-
-    async def run_temporal(self, context: FlockContext) -> dict:
-        """Run the BatchAgent via Temporal.
-
-        For each batch, the agent's evaluation is performed as a separate Temporal activity.
-        The results are then aggregated.
-        """
-        try:
-            from temporalio.client import Client
-
-            from flock.workflow.agent_activities import (
-                run_declarative_agent_activity,
-            )
-            from flock.workflow.temporal_setup import run_activity
-
-            # Connect to Temporal
-            client = await Client.connect("localhost:7233", namespace="default")
-
-            # Validate and prepare input
-            iterable = context.get_variable(self.iter_input)
-            if not isinstance(iterable, list):
-                error_msg = (
-                    f"Expected a list for key '{self.iter_input}' in context."
-                )
-                return {"error": error_msg}
-
-            # Partition into batches
-            batches: list[list[Any]] = [
-                iterable[i : i + self.batch_size]
-                for i in range(0, len(iterable), self.batch_size)
-            ]
-
-            # Process batches
-            tasks = []
-            for batch in batches:
-                # Prepare context for this batch
-                new_state = context.state.copy()
-                new_state[self.iter_input] = batch
-                context_data = {
-                    "state": new_state,
-                    "history": [],  # you might choose to pass along history if needed
-                    "agent_definitions": [],
-                }
-                agent_data = self.dict()
-                task_id = f"{self.name}_{uuid.uuid4().hex[:4]}"
-
-                # Create temporal activity task
-                tasks.append(
-                    run_activity(
-                        client,
-                        task_id,
-                        run_declarative_agent_activity,
-                        {
-                            "agent_data": agent_data,
-                            "context_data": context_data,
-                        },
-                    )
-                )
-
-            batch_results = await asyncio.gather(*tasks)
-
-            # Aggregate the outputs
-            output_keys = self._parse_keys(self.output)
-            aggregated = {key: [] for key in output_keys}
-            for res in batch_results:
-                for key in output_keys:
-                    aggregated[key].append(res.get(key))
-            aggregated["batch_results"] = batch_results
-            return aggregated
-
-        except Exception:
-            raise

flock/agents/loop_agent.py

@@ -1,117 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-from pydantic import Field
-
-from flock.core.context.context import FlockContext
-from flock.core.flock_agent import FlockAgent
-
-
-class LoopAgent(FlockAgent):
-    """An agent that executes its logic in a loop until a termination condition is met.
-
-    Attributes:
-        input: Input domain for the agent
-        output: Output types for the agent
-        tools: Tools the agent is allowed to use
-        max_iterations: Maximum number of iterations before forced termination
-        termination_condition: Optional callable that determines when to stop the loop
-    """
-
-    input: str = Field(default="", description="Input domain for the agent")
-    output: str = Field(default="", description="Output types for the agent")
-    tools: list[Callable] | None = Field(default=None, description="Tools the agent is allowed to use")
-    max_iterations: int = Field(default=10, description="Maximum number of iterations")
-    termination_condition: Callable[[dict[str, Any]], bool] | None = Field(
-        default=None, description="Optional function to determine loop termination"
-    )
-
-    async def _process_iteration(self, context: FlockContext, iteration: int) -> dict[str, Any]:
-        """Process a single iteration of the loop."""
-        try:
-            # Here you would implement the actual iteration logic
-            # For now, we'll just return a simple result
-            return {"iteration": iteration, "status": "completed"}
-        except Exception:
-            raise
-
-    def _should_continue(self, result: dict[str, Any], iteration: int) -> bool:
-        """Determine if the loop should continue."""
-        if iteration >= self.max_iterations:
-            return False
-
-        if self.termination_condition:
-            should_terminate = self.termination_condition(result)
-            return not should_terminate
-
-        return True
-
-    async def run(self, context: FlockContext) -> dict[str, Any]:
-        """Run the agent in a loop until the termination condition is met or max iterations reached."""
-        try:
-            results = []
-            iteration = 0
-
-            while True:
-                result = await self._process_iteration(context, iteration)
-                results.append(result)
-
-                # Check termination conditions
-                if not self._should_continue(result, iteration):
-                    break
-
-                iteration += 1
-
-            return {
-                "iterations": iteration + 1,
-                "results": results,
-                "final_result": results[-1] if results else None,
-            }
-
-        except Exception:
-            raise
-
-    async def run_temporal(self, context: FlockContext) -> dict[str, Any]:
-        """Run the loop agent via Temporal."""
-        try:
-            from temporalio.client import Client
-
-            from flock.workflow.agent_activities import run_agent_activity
-            from flock.workflow.temporal_setup import run_activity
-
-            client = await Client.connect("localhost:7233", namespace="default")
-
-            results = []
-            iteration = 0
-
-            while True:
-                # Process iteration as a temporal activity
-                context_data = {
-                    "state": context.state,
-                    "history": [record.__dict__ for record in context.history],
-                    "agent_definitions": [definition.__dict__ for definition in context.agent_definitions],
-                }
-                agent_data = self.dict()
-
-                result = await run_activity(
-                    client,
-                    f"{self.name}_iteration_{iteration}",
-                    run_agent_activity,
-                    {"agent_data": agent_data, "context_data": context_data},
-                )
-                results.append(result)
-
-                # Check termination conditions
-                if not self._should_continue(result, iteration):
-                    break
-
-                iteration += 1
-
-            return {
-                "iterations": iteration + 1,
-                "results": results,
-                "final_result": results[-1] if results else None,
-            }
-
-        except Exception:
-            raise