flock-core 0.4.543__py3-none-any.whl → 0.5.0__py3-none-any.whl

flock/modules/zep/zep_module.py

@@ -1,192 +0,0 @@
-import uuid
-from typing import Any
-
-from pydantic import Field
-from zep_python.client import Zep
-from zep_python.types import Message as ZepMessage, SessionSearchResult
-
-from flock.core.context.context import FlockContext
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_module import FlockModule, FlockModuleConfig
-from flock.core.flock_registry import flock_component
-from flock.core.logging.logging import get_logger
-
-logger = get_logger("module.zep")
-
-
-class ZepModuleConfig(FlockModuleConfig):
-    """Configuration for the Zep module."""
-
-    zep_url: str = "http://localhost:8000"
-    zep_api_key: str = "apikey"
-    min_fact_rating: float = Field(
-        default=0.7, description="Minimum rating for facts to be considered"
-    )
-    enable_read: bool = True
-    enable_write: bool = False
-    top_k: int = Field(default=10, description="Number of memories to retrieve")
-    user_id: str = Field(default="flock", description="User ID the memories will be associated with")
-    agent_id: str = Field(default="flock", description="Agent ID the memories will be associated with")
-    memory_input_key: str | None = Field(default=None, description="Input key to use for memory, if none the description of the agent will be used")
-
-
-
-@flock_component(config_class=ZepModuleConfig)
-class ZepModule(FlockModule):
-    """Module that adds Zep capabilities to a Flock agent."""
-
-    name: str = "zep"
-    config: ZepModuleConfig = ZepModuleConfig()
-    session_id: str | None = None
-    user_id: str | None = None
-
-    def __init__(self, name, config: ZepModuleConfig) -> None:
-        """Initialize Zep module."""
-        super().__init__(name=name, config=config)
-        logger.debug("Initializing Zep module")
-        zep_client = Zep(
-            base_url=self.config.zep_url, api_key=self.config.zep_api_key
-        )
-        self.user_id = self.name
-        self._setup_user(zep_client)
-        self.session_id = str(uuid.uuid4())
-        self._setup_session(zep_client)
-
-    def _setup_user(self, zep_client: Zep) -> None:
-        """Set up user in Zep."""
-        if not zep_client or not self.user_id:
-            raise ValueError("Zep service or user_id not initialized")
-
-        try:
-            user = zep_client.user.get(user_id=self.user_id)
-            if not user:
-                zep_client.user.add(user_id=self.user_id)
-        except Exception:
-            zep_client.user.add(user_id=self.user_id)
-
-    def _setup_session(self, zep_client: Zep) -> None:
-        """Set up new session."""
-        if not zep_client or not self.user_id or not self.session_id:
-            raise ValueError(
-                "Zep service, user_id, or session_id not initialized"
-            )
-
-        zep_client.memory.add_session(
-            user_id=self.user_id,
-            session_id=self.session_id,
-        )
-
-    def get_client(self) -> Zep:
-        """Get Zep client."""
-        return Zep(
-            base_url=self.config.zep_url, api_key=self.config.zep_api_key
-        )
-
-    def get_memory(self, zep_client: Zep) -> str | None:
-        """Get memory for the current session."""
-        if not zep_client or not self.session_id:
-            logger.error("Zep service or session_id not initialized")
-            return None
-
-        try:
-            memory = zep_client.memory.get(
-                self.session_id, min_rating=self.config.min_fact_rating
-            )
-            if memory:
-                return f"{memory.relevant_facts}"
-        except Exception as e:
-            logger.error(f"Error fetching memory: {e}")
-            return None
-
-        return None
-
-    def split_text(
-        self, text: str | None, max_length: int = 1000
-    ) -> list[ZepMessage]:
-        """Split text into smaller chunks."""
-        result: list[ZepMessage] = []
-        if not text:
-            return result
-        if len(text) <= max_length:
-            return [ZepMessage(role="user", content=text, role_type="user")]
-        for i in range(0, len(text), max_length):
-            result.append(
-                ZepMessage(
-                    role="user",
-                    content=text[i : i + max_length],
-                    role_type="user",
-                )
-            )
-        return result
-
-    def add_to_memory(self, text: str, zep_client: Zep) -> None:
-        """Add text to memory."""
-        if not zep_client or not self.session_id:
-            logger.error("Zep service or session_id not initialized")
-            return
-
-        messages = self.split_text(text)
-        zep_client.memory.add(session_id=self.session_id, messages=messages)
-
-    def search_memory(
-        self, query: str, zep_client: Zep
-    ) -> list[SessionSearchResult]:
-        """Search memory for a query."""
-        if not zep_client or not self.user_id:
-            logger.error("Zep service or user_id not initialized")
-            return []
-
-        response = zep_client.memory.search_sessions(
-            text=query,
-            user_id=self.user_id,
-            search_scope="facts",
-            min_fact_rating=self.config.min_fact_rating,
-        )
-        if not response.results:
-            return []
-        return response.results
-
-    async def on_post_evaluate(
-        self,
-        agent: FlockAgent,
-        inputs: dict[str, Any],
-        context: FlockContext | None = None,
-        result: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Format and display the output."""
-        if not self.config.enable_write:
-            return result
-        logger.debug("Saving data to memory")
-        zep_client = Zep(
-            base_url=self.config.zep_url, api_key=self.config.zep_api_key
-        )
-        self.add_to_memory(str(result), zep_client)
-        return result
-
-    async def on_pre_evaluate(
-        self,
-        agent: FlockAgent,
-        inputs: dict[str, Any],
-        context: FlockContext | None = None,
-    ) -> dict[str, Any]:
-        """Format and display the output."""
-        if not self.config.enable_read:
-            return inputs
-
-        zep_client = Zep(
-            base_url=self.config.zep_url, api_key=self.config.zep_api_key
-        )
-
-        logger.debug("Searching memory")
-        facts = self.search_memory(str(inputs), zep_client)
-
-        # Add memory to inputs
-        facts_str = ""
-        if facts:
-            for fact in facts:
-                facts_str += fact.fact.fact + "\n"
-            logger.debug("Found facts in memory: {}", facts_str)
-            agent.input = agent.input + ", memory"
-            inputs["memory"] = facts_str
-
-        return inputs

flock/platform/docker_tools.py

@@ -1,49 +0,0 @@
-import subprocess
-import time
-
-
-def _check_docker_running():
-    """Check if Docker is running by calling 'docker info'."""
-    try:
-        result = subprocess.run(
-            ["docker", "info"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        return result.returncode == 0
-    except Exception:
-        return False
-
-
-def _start_docker():
-    """Attempt to start Docker.
-    This example first tries 'systemctl start docker' and then 'service docker start'.
-    Adjust as needed for your environment.
-    """
-    try:
-        print("Attempting to start Docker...")
-        result = subprocess.run(
-            ["sudo", "systemctl", "start", "docker"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        if result.returncode != 0:
-            result = subprocess.run(
-                ["sudo", "service", "docker", "start"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-        # Give Docker a moment to start.
-        time.sleep(3)
-        if _check_docker_running():
-            print("Docker is now running.")
-            return True
-        else:
-            print("Docker did not start successfully.")
-            return False
-    except Exception as e:
-        print(f"Exception when trying to start Docker: {e}")
-        return False

flock/platform/jaeger_install.py

@@ -1,86 +0,0 @@
-import socket
-import subprocess
-from urllib.parse import urlparse
-
-
-class JaegerInstaller:
-    jaeger_endpoint: str = None
-    jaeger_transport: str = "grpc"
-
-    def _check_jaeger_running(self):
-        """Check if Jaeger is reachable by attempting a socket connection.
-        For HTTP transport, we parse the URL; for gRPC, we expect "host:port".
-        """
-        try:
-            if self.jaeger_transport == "grpc":
-                host, port = self.jaeger_endpoint.split(":")
-                port = int(port)
-            elif self.jaeger_transport == "http":
-                parsed = urlparse(self.jaeger_endpoint)
-                host = parsed.hostname
-                port = parsed.port if parsed.port else 80
-            else:
-                return False
-
-            # Try connecting to the host and port.
-            with socket.create_connection((host, port), timeout=3):
-                return True
-        except Exception:
-            return False
-
-    def _is_jaeger_container_running(self):
-        """Check if a Jaeger container (using the official all-in-one image) is running.
-        This uses 'docker ps' to filter for containers running the Jaeger image.
-        """
-        try:
-            result = subprocess.run(
-                [
-                    "docker",
-                    "ps",
-                    "--filter",
-                    "ancestor=jaegertracing/all-in-one:latest",
-                    "--format",
-                    "{{.ID}}",
-                ],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-            return bool(result.stdout.strip())
-        except Exception:
-            return False
-
-    def _provision_jaeger_container(self):
-        """Provision a Jaeger container using Docker."""
-        try:
-            print("Provisioning Jaeger container using Docker...")
-            result = subprocess.run(
-                [
-                    "docker",
-                    "run",
-                    "-d",
-                    "--name",
-                    "jaeger",
-                    "-p",
-                    "16686:16686",
-                    "-p",
-                    "14250:14250",
-                    "-p",
-                    "14268:14268",
-                    "jaegertracing/all-in-one:latest",
-                ],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-            if result.returncode == 0:
-                print("Jaeger container started successfully.")
-                return True
-            else:
-                print(
-                    f"Failed to start Jaeger container. Error: {result.stderr}"
-                )
-                return False
-        except Exception as e:
-            print(f"Exception when provisioning Jaeger container: {e}")
-            return False

flock/routers/__init__.py

@@ -1 +0,0 @@
-"""Routers for the Flock framework."""

flock/routers/agent/__init__.py

@@ -1 +0,0 @@
-"""Agent-based router implementation for the Flock framework."""

flock/routers/agent/agent_router.py

@@ -1,236 +0,0 @@
-"""Agent-based router implementation for the Flock framework."""
-
-from typing import Any
-
-from flock.core.context.context import FlockContext
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_registry import flock_component
-from flock.core.flock_router import (
-    FlockRouter,
-    FlockRouterConfig,
-    HandOffRequest,
-)
-from flock.core.logging.formatters.themes import OutputTheme
-from flock.core.logging.logging import get_logger
-from flock.evaluators.declarative.declarative_evaluator import (
-    DeclarativeEvaluator,
-    DeclarativeEvaluatorConfig,
-)
-from flock.modules.output.output_module import OutputModule, OutputModuleConfig
-from flock.routers.agent.handoff_agent import (
-    AgentInfo,
-    HandoffAgent,
-)
-
-logger = get_logger("agent_router")
-
-
-class AgentRouterConfig(FlockRouterConfig):
-    """Configuration for the agent router.
-
-    This class extends FlockRouterConfig with parameters specific to the agent router.
-    """
-
-    with_output: bool = False
-    confidence_threshold: float = 0.5  # No additional parameters needed for now
-
-
-@flock_component(config_class=AgentRouterConfig)
-class AgentRouter(FlockRouter):
-    """Router that uses a FlockAgent to determine the next agent in a workflow.
-
-    This class is responsible for:
-    1. Creating and managing a HandoffAgent
-    2. Analyzing available agents in the registry
-    3. Using the HandoffAgent to determine the best next agent
-    4. Creating a HandOff object with the selected agent
-    """
-
-    def __init__(
-        self,
-        name: str = "agent_router",
-        config: AgentRouterConfig | None = None,
-    ):
-        """Initialize the AgentRouter.
-
-        Args:
-            registry: The agent registry containing all available agents
-            name: The name of the router
-            config: The router configuration
-        """
-        super().__init__(
-            name=name, config=config or AgentRouterConfig(name=name)
-        )
-
-    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
-        """
-        # Get all available agents from context.agent_definitions
-        agent_definitions = context.agent_definitions
-        handoff_agent = HandoffAgent(model=current_agent.model)
-        handoff_agent.evaluator = DeclarativeEvaluator(
-            name="evaluator",
-            config=DeclarativeEvaluatorConfig(
-                model=current_agent.model,
-                use_cache=True,
-                max_tokens=1000,
-                temperature=0.0,
-            ),
-        )
-        if self.config.with_output:
-            handoff_agent.add_module(
-                OutputModule(
-                    name="output",
-                    config=OutputModuleConfig(
-                        theme=OutputTheme.abernathy,
-                    ),
-                )
-            )
-        available_agents = self._get_available_agents(
-            agent_definitions, current_agent.name
-        )
-
-        if not available_agents:
-            logger.warning("No available agents for agent-based routing")
-            return HandOffRequest(
-                next_agent="",
-                output_to_input_merge_strategy="add",
-                override_next_agent=None,
-                override_context=None,
-            )
-
-        # Prepare input for the handoff agent
-        handoff_input = {
-            "current_agent_name": current_agent.name,
-            "current_agent_description": current_agent.description,
-            "current_agent_input": current_agent.input,
-            "current_agent_output": current_agent.output,
-            "current_result": result,
-            "available_agents": available_agents,
-        }
-
-        try:
-            # Run the handoff agent to determine the next agent
-            handoff_result = await handoff_agent.run_async(handoff_input)
-
-            # Extract the decision
-            next_agent_name = handoff_result.get("agent_name")
-            confidence = handoff_result.get("confidence")
-            reasoning = handoff_result.get("reasoning")
-            logger.info(
-                f"Agent router selected agent '{next_agent_name}' with confidence {confidence} and reasoning: {reasoning}"
-            )
-
-            if confidence < self.config.confidence_threshold:
-                logger.info(
-                    f"No suitable next agent found (best score: {confidence})"
-                )
-                return HandOffRequest(
-                    next_agent="",
-                    output_to_input_merge_strategy="add",
-                    override_next_agent=None,
-                    override_context=None,
-                )
-
-            next_agent = agent_definitions.get(next_agent_name)
-            if not next_agent:
-                logger.error(
-                    f"Selected agent '{next_agent_name}' not found in agent definitions"
-                )
-                return HandOffRequest(
-                    next_agent="",
-                    output_to_input_merge_strategy="add",
-                    override_next_agent=None,
-                    override_context=None,
-                )
-
-            logger.info(
-                f"Agent router selected agent '{next_agent_name}' with confidence {confidence}"
-            )
-            return HandOffRequest(
-                next_agent=next_agent_name,
-                output_to_input_merge_strategy="add",
-                override_next_agent=None,
-                override_context=None,
-            )
-
-        except Exception as e:
-            logger.error(f"Error in agent-based routing: {e}")
-            return HandOffRequest(
-                next_agent="",
-                output_to_input_merge_strategy="add",
-                override_next_agent=None,
-                override_context=None,
-            )
-
-    def _get_available_agents(
-        self, agent_definitions: dict[str, Any], current_agent_name: str
-    ) -> list[AgentInfo]:
-        """Get all available agents except the current one and the handoff agent.
-
-        Args:
-            agent_definitions: Dictionary of available agents
-            current_agent_name: Name of the current agent to exclude
-
-        Returns:
-            List of available agents as AgentInfo objects
-        """
-        agents = []
-        for agent_name in agent_definitions:
-            if agent_name != current_agent_name:
-                agent = agent_definitions[agent_name]
-                agent_info = AgentInfo(
-                    name=agent_name,
-                    description=agent.agent_data["description"]
-                    if agent.agent_data["description"]
-                    else "",
-                    input_schema=agent.agent_data["input"],
-                    output_schema=agent.agent_data["output"],
-                )
-                agents.append(agent_info)
-        return agents
-
-    def _get_schema_from_agent(
-        self, agent: Any, schema_type: str
-    ) -> dict[str, Any]:
-        """Extract input or output schema from an agent.
-
-        Args:
-            agent: The agent to extract schema from
-            schema_type: Either "input" or "output"
-
-        Returns:
-            Dictionary representation of the schema
-        """
-        schema = {}
-        schema_str = agent.agent_data.get(schema_type, "")
-
-        # Parse the schema string to extract field names, types, and descriptions
-        if schema_str:
-            fields = schema_str.split(",")
-            for field in fields:
-                field = field.strip()
-                if ":" in field:
-                    name, rest = field.split(":", 1)
-                    name = name.strip()
-                    schema[name] = rest.strip()
-                else:
-                    schema[field] = "Any"
-
-        return schema
-
-    # The _create_next_input method is no longer needed since we're using hand_off_mode="add"
-    # instead of manually preparing inputs for the next agent

flock/routers/agent/handoff_agent.py

@@ -1,58 +0,0 @@
-"""Handoff agent for the agent-based router."""
-
-from pydantic import BaseModel
-
-from flock.core.flock_agent import FlockAgent
-
-
-class AgentInfo(BaseModel):
-    """Information about an agent for handoff decisions."""
-
-    name: str
-    description: str = ""
-    input_schema: str = ""
-    output_schema: str = ""
-
-
-class HandoffDecision(BaseModel):
-    """Decision about which agent to hand off to."""
-
-    agent_name: str
-    confidence: float
-    reasoning: str
-
-
-class HandoffAgent(FlockAgent):
-    """Agent that decides which agent to hand off to next.
-
-    This agent analyzes the current agent's output and available agents
-    to determine the best next agent in the workflow.
-    """
-
-    def __init__(
-        self,
-        name: str = "handoff_agent",
-        model: str | None = None,
-        description: str = "Decides which agent to hand off to next",
-    ):
-        """Initialize the HandoffAgent.
-
-        Args:
-            name: The name of the agent
-            model: The model to use (e.g., 'openai/gpt-4o')
-            description: A human-readable description of the agent
-        """
-        super().__init__(
-            name=name,
-            model=model,
-            description=description,
-            input=(
-                "current_agent_name: str | Name of the current agent, "
-                "current_agent_description: str | Description of the current agent, "
-                "current_agent_input: str | Input schema of the current agent, "
-                "current_agent_output: str | Output schema of the current agent, "
-                "current_result: dict | Output from the current agent, "
-                "available_agents: list[AgentInfo] | List of available agents"
-            ),
-            output="agent_name: str | Name of the agent to hand off to, confidence: float | Confidence in the decision, reasoning: str | Reasoning for the decision",
-        )