flock-core 0.5.4__py3-none-any.whl → 0.5.5__py3-none-any.whl

flock/agent.py

@@ -249,7 +249,26 @@ class Agent(metaclass=AutoTracedMeta):
             accumulated_metrics: dict[str, float] = {}
             for engine in engines:
                 current_inputs = await engine.on_pre_evaluate(self, ctx, current_inputs)
-                result = await engine.evaluate(self, ctx, current_inputs)
+                use_batch_mode = bool(getattr(ctx, "is_batch", False))
+                try:
+                    if use_batch_mode:
+                        logger.debug(
+                            "Agent %s: routing %d artifacts to %s.evaluate_batch",
+                            self.name,
+                            len(current_inputs.artifacts),
+                            engine.__class__.__name__,
+                        )
+                        result = await engine.evaluate_batch(self, ctx, current_inputs)
+                    else:
+                        result = await engine.evaluate(self, ctx, current_inputs)
+                except NotImplementedError:
+                    if use_batch_mode:
+                        logger.error(
+                            "Agent %s: engine %s does not implement evaluate_batch()",
+                            self.name,
+                            engine.__class__.__name__,
+                        )
+                    raise
 
                 # AUTO-WRAP: If engine returns BaseModel instead of EvalResult, wrap it
                 from flock.runtime import EvalResult as ER

flock/components.py

@@ -109,6 +109,38 @@ class EngineComponent(AgentComponent):
         """Override this method in your engine implementation."""
         raise NotImplementedError
 
+    async def evaluate_batch(self, agent: Agent, ctx: Context, inputs: EvalInputs) -> EvalResult:
+        """Process batch of accumulated artifacts (BatchSpec).
+
+        Override this method if your engine supports batch processing.
+
+        Args:
+            agent: Agent instance executing this engine
+            ctx: Execution context (ctx.is_batch will be True)
+            inputs: EvalInputs with inputs.artifacts containing batch items
+
+        Returns:
+            EvalResult with processed artifacts
+
+        Raises:
+            NotImplementedError: If engine doesn't support batching
+
+        Example:
+            >>> async def evaluate_batch(self, agent, ctx, inputs):
+            ...     events = inputs.all_as(Event)  # Get ALL items
+            ...     results = await bulk_process(events)
+            ...     return EvalResult.from_objects(*results, agent=agent)
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not support batch processing.\n\n"
+            f"To fix this:\n"
+            f"1. Remove BatchSpec from agent subscription, OR\n"
+            f"2. Implement evaluate_batch() in {self.__class__.__name__}, OR\n"
+            f"3. Use a batch-aware engine (e.g., CustomBatchEngine)\n\n"
+            f"Agent: {agent.name}\n"
+            f"Engine: {self.__class__.__name__}"
+        )
+
     async def fetch_conversation_context(
         self,
         ctx: Context,