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

flock/agents/trigger_agent.py

@@ -1,113 +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 TriggerAgent(FlockAgent):
-    """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:
-            return self.trigger_condition(context.state)
-        except Exception:
-            raise
-
-    async def _execute_action(self, context: FlockContext) -> dict[str, Any]:
-        """Execute the agent's action once triggered."""
-        try:
-            # 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")}
-            return result
-        except Exception:
-            raise
-
-    async def run(self, context: FlockContext) -> dict[str, Any]:
-        """Run the agent, waiting for and responding to triggers."""
-        import asyncio
-        import time
-
-        try:
-            start_time = time.time()
-            triggered = False
-
-            while (time.time() - start_time) < self.max_wait_time:
-                if await self._evaluate_trigger(context):
-                    triggered = True
-                    break
-
-                await asyncio.sleep(self.trigger_check_interval)
-
-            if not triggered:
-                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:
-            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
-
-            client = await Client.connect("localhost:7233", namespace="default")
-
-            # 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()
-
-            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"):
-                return monitor_result
-
-            # Second activity: Execute action
-            action_result = await run_activity(
-                client,
-                f"{self.name}_action",
-                run_agent_activity,
-                {"agent_data": agent_data, "context_data": context_data},
-            )
-
-            return action_result
-
-        except Exception:
-            raise

flock/agents/user_agent.py

@@ -1,145 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-from pydantic import Field
-from temporalio import activity
-
-from flock.core.context.context import FlockContext
-from flock.core.flock_agent import FlockAgent
-
-
-@activity.defn
-async def run_user_agent_activity(context: dict[str, Any]) -> dict[str, Any]:
-    """Temporal activity to process a user agent task.
-
-    Expects context to contain:
-      - "model": the model name
-      - "agent_input": the key used for the input
-      - "output": the agent output specification
-      - "init_input": the initial input
-      - "tools": (optional) list of tools
-    """
-    try:
-        import dspy
-
-        model = context.get("model")
-        agent_input = context.get("agent_input")
-        output = context.get("output")
-        init_input = context.get("init_input")
-        tools = context.get("tools")
-
-        lm = dspy.LM(model)
-        dspy.configure(lm=lm)
-
-        if tools:
-            agent_task = dspy.ReAct(f"{agent_input} -> {output}", tools=tools)
-        else:
-            agent_task = dspy.Predict(f"{agent_input} -> {output}")
-
-        kwargs = {agent_input: init_input}
-        result = agent_task(**kwargs).toDict()
-        result[agent_input] = init_input
-
-        return result
-
-    except Exception:
-        raise
-
-
-class UserAgent(FlockAgent):
-    """An agent that evaluates declarative inputs with user interaction capabilities.
-
-    This agent extends the base Agent class with the ability to interact with users
-    during execution, while maintaining compatibility with both local and Temporal
-    execution modes.
-
-    Attributes:
-        input: Input domain for the agent
-        output: Output types for the agent
-        tools: Tools the agent is allowed to use
-        require_confirmation: Whether to require user confirmation before proceeding
-    """
-
-    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")
-    require_confirmation: bool = Field(default=False, description="Whether to require user confirmation")
-
-    async def _configure_model(self) -> tuple[Any, Any]:
-        """Configure the model and create the appropriate task."""
-        try:
-            import dspy
-
-            lm = dspy.LM(self.model)
-            dspy.configure(lm=lm)
-
-            if self.tools:
-                agent_task = dspy.ReAct(f"{self.input} -> {self.output}", tools=self.tools)
-            else:
-                agent_task = dspy.Predict(f"{self.input} -> {self.output}")
-
-            return lm, agent_task
-
-        except Exception:
-            raise
-
-    async def _execute_task(self, task: Any, context: FlockContext) -> dict[str, Any]:
-        """Execute the configured task."""
-        try:
-            kwargs = {self.input: context.get_variable("init_input")}
-            result = task(**kwargs).toDict()
-            result[self.input] = kwargs[self.input]
-            return result
-
-        except Exception:
-            raise
-
-    async def run(self, context: FlockContext) -> dict[str, Any]:
-        """Run the agent on a task with optional user interaction."""
-        try:
-            # Configure model and task
-            _, task = await self._configure_model()
-
-            # Execute with user confirmation if required
-            if self.require_confirmation:
-                # Here you would implement user confirmation logic
-                # For now, we'll just proceed
-                pass
-
-            # Execute the task
-            result = await self._execute_task(task, context)
-            return result
-
-        except Exception:
-            raise
-
-    async def run_temporal(self, context: FlockContext) -> dict[str, Any]:
-        """Run the user agent via Temporal."""
-        try:
-            from temporalio.client import Client
-
-            from flock.workflow.temporal_setup import run_activity
-
-            client = await Client.connect("localhost:7233", namespace="default")
-
-            # Prepare context for temporal activity
-            activity_context = {
-                "model": self.model,
-                "agent_input": self.input,
-                "output": self.output,
-                "init_input": context.get_variable("init_input"),
-                "tools": self.tools,
-            }
-
-            # Execute the activity
-            result = await run_activity(
-                client,
-                self.name,
-                run_user_agent_activity,
-                activity_context,
-            )
-
-            return result
-
-        except Exception:
-            raise