flock-core 0.1.2__py3-none-any.whl → 0.2.2__py3-none-any.whl

flock/agents/declarative_agent.py

@@ -1,166 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-import dspy  # your dspy package for LM, Predict, ReAct, etc.
-from pydantic import Field
-
-from flock.core.agent import Agent
-from flock.core.context import FlockContext
-from flock.core.logging import flock_logger, performance_handler
-
-
-class DeclarativeAgent(Agent):
-    """An agent that evaluates declarative inputs.
-
-    Attributes:
-      input: A comma‐separated list of input keys.
-             If a key is not found in the incoming FlockContext and only one input is expected,
-             then the value of "init_input" is used.
-      output: A comma‐separated list of output keys (any type annotations after ":" are ignored).
-      tools: An optional list of callables (tools) that the agent is allowed to use.
-      use_cache: Whether to cache agent results.
-    """
-
-    input: str = Field(description="Comma-separated input keys (e.g., 'blog_idea' or 'url, context')")
-    output: str = Field(description="Comma-separated output keys (e.g., 'title, headers')")
-    tools: list[Callable[..., Any]] | None = Field(default=None, description="Tools the agent is allowed to use")
-    use_cache: bool = Field(default=False, description="Whether to use the cache for this agent")
-
-    def _parse_keys(self, keys_str: str) -> list[str]:
-        """Split a comma‐separated string and strip any type annotations.
-        For example, "a, b: list[str]" becomes ["a", "b"].
-        """
-        keys = []
-        for part in keys_str.split(","):
-            part = part.strip()
-            if not part:
-                continue
-            # Remove any type annotation (everything after a colon)
-            if ":" in part:
-                key = part.split(":", 1)[0].strip()
-            else:
-                key = part
-            keys.append(key)
-        return keys
-
-    def _build_input(self, context: FlockContext) -> dict:
-        """Build the dictionary of inputs for the agent based on its input specification.
-
-        For each key in the agent's input string:
-          - If the key is "context" (case-insensitive), pass the entire FlockContext.
-          - Otherwise, use context.get_variable() to fetch the value.
-          - If the key is not found and only one key is expected, default to context["init_input"].
-        """
-        input_keys = self._parse_keys(self.input)
-        inputs = {}
-        for key in input_keys:
-            if key.lower() == "context":
-                inputs[key] = context
-            else:
-                value = context.get_variable(key)
-                if value is None and len(input_keys) == 1:
-                    value = context.get_variable("init_input")
-                inputs[key] = value
-        return inputs
-
-    def _configure_task(self):
-        """Configure the dspy language model and choose a task constructor.
-        If tools are provided, ReAct is used; otherwise, Predict.
-        """
-        with performance_handler.track_time("model_configuration"):
-            flock_logger.debug(f"Configuring {self.model} for {'ReAct' if self.tools else 'Predict'} task")
-            lm = dspy.LM(self.model)
-            dspy.configure(lm=lm)
-            return dspy.ReAct if self.tools else dspy.Predict
-
-    async def _evaluate(self, context: FlockContext, input_overrides: dict | None = None) -> dict:
-        """Evaluate the agent by:
-        1. Building an input dictionary from the FlockContext (merging any overrides),
-        2. Building a prompt like "input1, input2 -> output1, output2",
-        3. Instantiating and executing the dspy task (Predict or ReAct),
-        4. Returning the resulting dictionary.
-        """
-        try:
-            # Build inputs
-            with performance_handler.track_time("input_preparation"):
-                inputs = self._build_input(context)
-                if input_overrides:
-                    inputs.update(input_overrides)
-                input_keys = self._parse_keys(self.input)
-                output_keys = self._parse_keys(self.output)
-                prompt = f"{', '.join(input_keys)} -> {', '.join(output_keys)}"
-                flock_logger.debug("Prepared inputs", inputs=inputs, prompt=prompt)
-
-            # Configure and execute task
-            with performance_handler.track_time("task_execution"):
-                task_constructor = self._configure_task()
-                if self.tools:
-                    flock_logger.info("Creating ReAct task with tools", num_tools=len(self.tools))
-                    agent_task = task_constructor(prompt, tools=self.tools)
-                else:
-                    flock_logger.info("Creating Predict task")
-                    agent_task = task_constructor(prompt)
-
-                flock_logger.info("Executing task...")
-                result = agent_task(**inputs).toDict()
-
-            # Process result
-            for key in input_keys:
-                result.setdefault(key, inputs.get(key))
-            flock_logger.success("Task completed successfully", output_keys=list(result.keys()))
-            return result
-
-        except Exception as e:
-            flock_logger.error(
-                "Task execution failed",
-                error=str(e),
-                agent=self.name,
-                inputs=inputs,
-                prompt=prompt,
-            )
-            raise
-
-    async def run(self, context: FlockContext) -> dict:
-        """Run the agent on the provided FlockContext (locally)."""
-        flock_logger.info(f"Running agent locally: {self.name}")
-        return await self._evaluate(context)
-
-    async def run_temporal(self, context: FlockContext) -> dict:
-        """Run the agent via Temporal by serializing its parameters and the FlockContext and
-        calling a dedicated Temporal activity.
-        """
-        from temporalio.client import Client
-
-        from flock.workflow.agent_activities import run_declarative_agent_activity
-        from flock.workflow.temporal_setup import run_activity
-
-        try:
-            with performance_handler.track_time("temporal_setup"):
-                # Connect to Temporal (adjust the host/namespace as needed)
-                flock_logger.info("Connecting to Temporal...")
-                client = await Client.connect("localhost:7233", namespace="default")
-
-                # Serialize the FlockContext and agent
-                flock_logger.debug("Serializing context and agent data")
-                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()
-
-            # Run the activity
-            with performance_handler.track_time("temporal_activity"):
-                flock_logger.info(f"Starting Temporal activity: {self.name}")
-                result = await run_activity(
-                    client,
-                    self.name,
-                    run_declarative_agent_activity,
-                    {"agent_data": agent_data, "context_data": context_data},
-                )
-                flock_logger.success("Temporal activity completed successfully")
-                return result
-
-        except Exception as e:
-            flock_logger.error(f"Temporal execution failed: {e}", agent=self.name)
-            raise

flock/agents/loop_agent.py

@@ -1,178 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-from pydantic import Field
-
-from flock.core.agent import Agent
-from flock.core.context import FlockContext
-from flock.core.logging import flock_logger, live_update_handler, performance_handler
-
-
-class LoopAgent(Agent):
-    """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:
-            with performance_handler.track_time(f"iteration_{iteration}"):
-                flock_logger.debug(f"Processing iteration {iteration}", agent=self.name)
-                # Here you would implement the actual iteration logic
-                # For now, we'll just return a simple result
-                return {"iteration": iteration, "status": "completed"}
-        except Exception as e:
-            flock_logger.error(
-                f"Error in iteration {iteration}",
-                error=str(e),
-                agent=self.name,
-            )
-            raise
-
-    def _should_continue(self, result: dict[str, Any], iteration: int) -> bool:
-        """Determine if the loop should continue."""
-        if iteration >= self.max_iterations:
-            flock_logger.warning(
-                "Maximum iterations reached",
-                max_iterations=self.max_iterations,
-                agent=self.name,
-            )
-            return False
-
-        if self.termination_condition:
-            should_terminate = self.termination_condition(result)
-            if should_terminate:
-                flock_logger.info(
-                    "Termination condition met",
-                    iteration=iteration,
-                    agent=self.name,
-                )
-            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:
-            flock_logger.info(f"Starting loop agent: {self.name}")
-            results = []
-            iteration = 0
-
-            with live_update_handler.progress_tracker("Loop Progress") as update_progress:
-                while True:
-                    # Update progress based on iteration count
-                    progress = min((iteration + 1) * 100 / self.max_iterations, 100)
-                    update_progress(progress)
-
-                    # Process iteration with status tracking
-                    with live_update_handler.update_activity_status(
-                        f"{self.name}_iteration_{iteration}",
-                        f"Iteration {iteration + 1}",
-                        "Running",
-                        {"max_iterations": self.max_iterations},
-                    ):
-                        result = await self._process_iteration(context, iteration)
-                        results.append(result)
-
-                    # Check termination conditions
-                    if not self._should_continue(result, iteration):
-                        break
-
-                    iteration += 1
-
-            flock_logger.success(
-                f"Loop completed successfully",
-                total_iterations=iteration + 1,
-                agent=self.name,
-            )
-            return {
-                "iterations": iteration + 1,
-                "results": results,
-                "final_result": results[-1] if results else None,
-            }
-
-        except Exception as e:
-            flock_logger.error(
-                "Loop execution failed",
-                error=str(e),
-                agent=self.name,
-                iteration=iteration,
-            )
-            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
-
-            with performance_handler.track_time("temporal_setup"):
-                flock_logger.info(f"Starting temporal loop agent: {self.name}")
-                client = await Client.connect("localhost:7233", namespace="default")
-
-            results = []
-            iteration = 0
-
-            with live_update_handler.update_workflow_status(
-                self.name, "Running", {"phase": "loop_execution", "max_iterations": self.max_iterations}
-            ):
-                while True:
-                    # Process iteration as a temporal activity
-                    with performance_handler.track_time(f"temporal_iteration_{iteration}"):
-                        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()
-
-                        flock_logger.info(f"Starting temporal iteration {iteration + 1}")
-                        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
-
-            flock_logger.success(
-                "Temporal loop completed successfully",
-                total_iterations=iteration + 1,
-                agent=self.name,
-            )
-            return {
-                "iterations": iteration + 1,
-                "results": results,
-                "final_result": results[-1] if results else None,
-            }
-
-        except Exception as e:
-            flock_logger.error(
-                "Temporal loop execution failed",
-                error=str(e),
-                agent=self.name,
-                iteration=iteration,
-            )
-            raise

flock/agents/trigger_agent.py

@@ -1,191 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-from pydantic import Field
-
-from flock.core.agent import Agent
-from flock.core.context import FlockContext
-from flock.core.logging import flock_logger, live_update_handler, performance_handler
-
-
-class TriggerAgent(Agent):
-    """An agent that executes based on specific triggers/conditions.
-
-    Attributes:
-        input: Input domain for the agent
-        output: Output types for the agent
-        tools: Tools the agent is allowed to use
-        trigger_condition: Callable that evaluates whether the agent should execute
-        trigger_check_interval: How often to check the trigger condition (in seconds)
-        max_wait_time: Maximum time to wait for trigger (in seconds)
-    """
-
-    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")
-    trigger_condition: Callable[[dict[str, Any]], bool] = Field(
-        ..., description="Function that evaluates trigger conditions"
-    )
-    trigger_check_interval: float = Field(default=1.0, description="Interval between trigger checks (seconds)")
-    max_wait_time: float = Field(default=60.0, description="Maximum time to wait for trigger (seconds)")
-
-    async def _evaluate_trigger(self, context: FlockContext) -> bool:
-        """Evaluate the trigger condition."""
-        try:
-            with performance_handler.track_time("trigger_evaluation"):
-                flock_logger.debug("Evaluating trigger condition", agent=self.name)
-                result = self.trigger_condition(context.state)
-                flock_logger.debug(
-                    "Trigger evaluation result",
-                    triggered=result,
-                    agent=self.name,
-                )
-                return result
-        except Exception as e:
-            flock_logger.error(
-                "Trigger evaluation failed",
-                error=str(e),
-                agent=self.name,
-            )
-            raise
-
-    async def _execute_action(self, context: FlockContext) -> dict[str, Any]:
-        """Execute the agent's action once triggered."""
-        try:
-            with performance_handler.track_time("action_execution"):
-                flock_logger.info("Executing triggered action", agent=self.name)
-                # Here you would implement the actual action logic
-                # For now, we'll just return a simple result
-                result = {"status": "completed", "trigger_time": context.state.get("current_time")}
-                flock_logger.success("Action executed successfully", agent=self.name)
-                return result
-        except Exception as e:
-            flock_logger.error(
-                "Action execution failed",
-                error=str(e),
-                agent=self.name,
-            )
-            raise
-
-    async def run(self, context: FlockContext) -> dict[str, Any]:
-        """Run the agent, waiting for and responding to triggers."""
-        import asyncio
-        import time
-
-        try:
-            flock_logger.info(f"Starting trigger agent: {self.name}")
-            start_time = time.time()
-            triggered = False
-
-            with live_update_handler.progress_tracker("Waiting for trigger") as update_progress:
-                while (time.time() - start_time) < self.max_wait_time:
-                    # Update progress based on elapsed time
-                    elapsed = time.time() - start_time
-                    progress = min(elapsed * 100 / self.max_wait_time, 100)
-                    update_progress(progress)
-
-                    # Check trigger with status tracking
-                    with live_update_handler.update_activity_status(
-                        self.name,
-                        "Checking Trigger",
-                        "Running",
-                        {
-                            "elapsed_time": f"{elapsed:.1f}s",
-                            "max_wait_time": f"{self.max_wait_time:.1f}s",
-                        },
-                    ):
-                        if await self._evaluate_trigger(context):
-                            triggered = True
-                            break
-
-                    await asyncio.sleep(self.trigger_check_interval)
-
-                if not triggered:
-                    flock_logger.warning(
-                        "Trigger timeout reached",
-                        max_wait_time=self.max_wait_time,
-                        agent=self.name,
-                    )
-                    return {"error": "Trigger timeout", "max_wait_time": self.max_wait_time}
-
-                # Execute action when triggered
-                result = await self._execute_action(context)
-                return result
-
-        except Exception as e:
-            flock_logger.error(
-                "Trigger agent execution failed",
-                error=str(e),
-                agent=self.name,
-            )
-            raise
-
-    async def run_temporal(self, context: FlockContext) -> dict[str, Any]:
-        """Run the trigger 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
-
-            with performance_handler.track_time("temporal_setup"):
-                flock_logger.info(f"Starting temporal trigger agent: {self.name}")
-                client = await Client.connect("localhost:7233", namespace="default")
-
-            with live_update_handler.update_workflow_status(
-                self.name,
-                "Running",
-                {
-                    "phase": "trigger_monitoring",
-                    "check_interval": self.trigger_check_interval,
-                    "max_wait_time": self.max_wait_time,
-                },
-            ):
-                # First activity: Monitor trigger
-                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()
-
-                with performance_handler.track_time("temporal_trigger_monitoring"):
-                    flock_logger.info("Starting trigger monitoring activity")
-                    monitor_result = await run_activity(
-                        client,
-                        f"{self.name}_monitor",
-                        run_agent_activity,
-                        {"agent_data": agent_data, "context_data": context_data},
-                    )
-
-                if monitor_result.get("error"):
-                    flock_logger.warning(
-                        "Trigger monitoring ended without activation",
-                        reason=monitor_result["error"],
-                        agent=self.name,
-                    )
-                    return monitor_result
-
-                # Second activity: Execute action
-                with performance_handler.track_time("temporal_action_execution"):
-                    flock_logger.info("Starting action execution activity")
-                    action_result = await run_activity(
-                        client,
-                        f"{self.name}_action",
-                        run_agent_activity,
-                        {"agent_data": agent_data, "context_data": context_data},
-                    )
-
-                flock_logger.success(
-                    "Temporal trigger agent completed successfully",
-                    agent=self.name,
-                )
-                return action_result
-
-        except Exception as e:
-            flock_logger.error(
-                "Temporal trigger agent execution failed",
-                error=str(e),
-                agent=self.name,
-            )
-            raise