flock-core 0.5.0b28__py3-none-any.whl → 0.5.56b0__py3-none-any.whl

flock/components/routing/llm_routing_component.py

@@ -1,206 +0,0 @@
-# src/flock/components/routing/llm_routing_component.py
-"""LLM-based routing component implementation for the unified component architecture."""
-
-import json
-from typing import TYPE_CHECKING, Any
-
-import litellm
-from pydantic import Field
-
-from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.routing_component import RoutingComponent
-from flock.core.context.context import FlockContext
-
-# HandOffRequest removed - using agent.next_agent directly
-from flock.core.logging.logging import get_logger
-from flock.core.registry import flock_component
-
-if TYPE_CHECKING:
-    from flock.core.flock_agent import FlockAgent
-
-logger = get_logger("components.routing.llm")
-
-
-class LLMRoutingConfig(AgentComponentConfig):
-    """Configuration for the LLM routing component."""
-
-    temperature: float = Field(
-        default=0.2, description="Temperature for LLM routing decisions"
-    )
-    max_tokens: int = Field(
-        default=500, description="Maximum tokens for LLM response"
-    )
-    confidence_threshold: float = Field(
-        default=0.5, description="Minimum confidence threshold for routing"
-    )
-    model: str = Field(
-        default="azure/gpt-4.1", description="Model to use for routing decisions"
-    )
-    prompt_template: str = Field(
-        default="""You are a workflow routing assistant. Given the current agent's output and available next agents, determine which agent should execute next.
-
-Current Agent: {current_agent_name}
-Current Output: {current_output}
-
-Available Agents:
-{available_agents}
-
-Select the most appropriate next agent based on the current output. Respond with JSON in this exact format:
-{{"next_agent": "agent_name", "confidence": 0.8, "reasoning": "explanation"}}
-
-If no agent is suitable, use "next_agent": "" to end the workflow.""",
-        description="Template for LLM routing prompt"
-    )
-
-
-@flock_component(config_class=LLMRoutingConfig)
-class LLMRoutingComponent(RoutingComponent):
-    """Router that uses an LLM to determine the next agent in a workflow.
-    
-    This component analyzes the current agent's output and uses an LLM to
-    intelligently select the most appropriate next agent from available options.
-    """
-
-    config: LLMRoutingConfig = Field(
-        default_factory=LLMRoutingConfig
-    )
-
-    def __init__(
-        self,
-        name: str = "llm_router",
-        config: LLMRoutingConfig | None = None,
-        **data,
-    ):
-        if config is None:
-            config = LLMRoutingConfig()
-        super().__init__(name=name, config=config, **data)
-
-    def _get_available_agents(
-        self, agent_definitions: dict[str, Any], current_agent_name: str
-    ) -> list[str]:
-        """Get list of available agent names except the current one."""
-        available = []
-        for agent_name in agent_definitions:
-            if agent_name != current_agent_name:
-                available.append(agent_name)
-        return available
-
-    def _create_selection_prompt(
-        self,
-        current_agent: "FlockAgent",
-        result: dict[str, Any],
-        available_agents: list[str],
-    ) -> str:
-        """Create the prompt for LLM agent selection."""
-        # Format available agents
-        agents_list = []
-        for agent_name in available_agents:
-            agents_list.append(f"- {agent_name}")
-
-        available_agents_str = "\n".join(agents_list) if agents_list else "None available"
-
-        # Format current output
-        current_output = json.dumps(result, indent=2) if result else "No output"
-
-        return self.config.prompt_template.format(
-            current_agent_name=current_agent.name,
-            current_output=current_output,
-            available_agents=available_agents_str
-        )
-
-    async def _select_next_agent(
-        self,
-        current_agent: "FlockAgent",
-        result: dict[str, Any],
-        available_agents: list[str],
-    ) -> tuple[str, float]:
-        """Use an LLM to select the best next agent."""
-        if not available_agents:
-            logger.warning("No available agents for LLM routing")
-            return "", 0.0
-
-        # Create the selection prompt
-        prompt = self._create_selection_prompt(current_agent, result, available_agents)
-
-        try:
-            # Call the LLM
-            response = await litellm.acompletion(
-                model=self.config.model,
-                messages=[
-                    {"role": "user", "content": prompt}
-                ],
-                temperature=self.config.temperature,
-                max_tokens=self.config.max_tokens,
-            )
-
-            response_content = response.choices[0].message.content.strip()
-            logger.debug(f"LLM routing response: {response_content}")
-
-            # Parse the JSON response
-            try:
-                routing_decision = json.loads(response_content)
-                next_agent = routing_decision.get("next_agent", "")
-                confidence = routing_decision.get("confidence", 0.0)
-                reasoning = routing_decision.get("reasoning", "No reasoning provided")
-
-                logger.info(f"LLM routing decision: {next_agent} (confidence: {confidence}) - {reasoning}")
-
-                # Validate the selected agent is available
-                if next_agent and next_agent not in available_agents and next_agent != "":
-                    logger.warning(f"LLM selected unavailable agent '{next_agent}', ending workflow")
-                    return "", 0.0
-
-                return next_agent, confidence
-
-            except json.JSONDecodeError as e:
-                logger.error(f"Failed to parse LLM response as JSON: {e}")
-                return "", 0.0
-
-        except Exception as e:
-            logger.error(f"Error calling LLM for routing: {e}")
-            return "", 0.0
-
-    async def determine_next_step(
-        self,
-        agent: "FlockAgent",
-        result: dict[str, Any],
-        context: FlockContext | None = None,
-    ) -> None:
-        """Use LLM to determine the next agent based on current output."""
-        if not context:
-            logger.warning("No context provided for LLM routing")
-            return
-
-        logger.info(f"LLM routing from agent '{agent.name}'")
-
-        # Get available agents from context
-        agent_definitions = getattr(context, 'agent_definitions', {})
-        available_agents = self._get_available_agents(agent_definitions, agent.name)
-
-        logger.debug(f"Available agents for LLM routing: {available_agents}")
-
-        if not available_agents:
-            logger.warning("No available agents for LLM routing")
-            return
-
-        # Use LLM to select the next agent
-        next_agent_name, confidence = await self._select_next_agent(
-            agent, result, available_agents
-        )
-
-        logger.info(f"LLM routing result: {next_agent_name} (confidence: {confidence})")
-
-        # Check confidence threshold
-        if not next_agent_name or confidence < self.config.confidence_threshold:
-            logger.warning(
-                f"LLM routing confidence {confidence} below threshold {self.config.confidence_threshold}"
-            )
-            return
-
-        # Validate the selected agent exists
-        if next_agent_name not in agent_definitions:
-            logger.error(f"LLM selected non-existent agent '{next_agent_name}'")
-            return
-
-        logger.info(f"Successfully routed to agent '{next_agent_name}' with confidence {confidence}")
-        agent.next_agent = next_agent_name

flock/components/utility/__init__.py

@@ -1,22 +0,0 @@
-# src/flock/components/utility/__init__.py
-"""Utility components for the Flock framework."""
-
-from .example_utility_component import ExampleUtilityComponent, ExampleUtilityConfig, ExampleRecord
-from .feedback_utility_component import FeedbackUtilityComponent, FeedbackUtilityConfig
-from .memory_utility_component import MemoryUtilityComponent, MemoryUtilityConfig
-from .metrics_utility_component import MetricsUtilityComponent, MetricsUtilityConfig
-from .output_utility_component import OutputUtilityComponent, OutputUtilityConfig
-
-__all__ = [
-    "ExampleUtilityComponent",
-    "ExampleUtilityConfig",
-    "ExampleRecord",
-    "FeedbackUtilityComponent",
-    "FeedbackUtilityConfig",
-    "MemoryUtilityComponent",
-    "MemoryUtilityConfig",
-    "MetricsUtilityComponent",
-    "MetricsUtilityConfig", 
-    "OutputUtilityComponent",
-    "OutputUtilityConfig",
-]

flock/components/utility/example_utility_component.py

@@ -1,250 +0,0 @@
-"""Example utility component for n-shot learning."""
-
-from datetime import datetime, timedelta
-from typing import Any, Literal
-
-from pydantic import Field
-
-from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.utility_component import UtilityComponent
-from flock.core.context.context import FlockContext
-from flock.core.logging.logging import get_logger
-from flock.core.registry import flock_component
-
-if TYPE_CHECKING:
-    from flock.core.flock_agent import FlockAgent
-    from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
-
-logger = get_logger("components.utility.example")
-
-
-class ExampleUtilityConfig(AgentComponentConfig):
-    """Configuration for the ExampleUtilityComponent."""
-    
-    # Storage configuration
-    storage_type: Literal["sqlite", "azure"] = Field(
-        default="sqlite",
-        description="Type of storage backend for example data"
-    )
-    
-    # SQLite configuration
-    sqlite_db_path: str = Field(
-        default="./flock_examples.db",
-        description="Path to SQLite database file"
-    )
-    
-    # Azure Table Storage configuration
-    azure_connection_string: str | None = Field(
-        default=None,
-        description="Azure Table Storage connection string"
-    )
-    azure_table_name: str = Field(
-        default="flockexamples",
-        description="Azure Table Storage table name"
-    )
-    
-    # Example selection criteria
-    max_examples: int = Field(
-        default=5,
-        description="Maximum number of examples to include"
-    )
-    example_timeframe_days: int = Field(
-        default=30,
-        description="Only include examples from the last N days"
-    )
-    
-    # Example injection settings
-    example_input_key: str = Field(
-        default="examples_context",
-        description="Input key to use for injected examples"
-    )
-    
-    # Example filtering
-    example_filter_keywords: list[str] = Field(
-        default_factory=list,
-        description="Keywords to filter examples (only include examples containing these)"
-    )
-    example_exclude_keywords: list[str] = Field(
-        default_factory=list,
-        description="Keywords to exclude examples containing these"
-    )
-
-
-@flock_component(config_class=ExampleUtilityConfig)
-class ExampleUtilityComponent(UtilityComponent):
-    """Utility component that injects relevant examples into agent inputs for n-shot learning."""
-    
-    config: ExampleUtilityConfig = Field(
-        default_factory=ExampleUtilityConfig,
-        description="Example component configuration"
-    )
-    
-    def __init__(self, name: str = "examples", config: ExampleUtilityConfig | None = None, **data):
-        super().__init__(name=name, config=config or ExampleUtilityConfig(), **data)
-        self._store: SharedLinkStoreInterface | None = None
-    
-    async def _get_store(self) -> SharedLinkStoreInterface:
-        """Get the appropriate example store based on configuration."""
-        if self._store is None:
-            if self.config.storage_type == "sqlite":
-                from flock.webapp.app.services.sharing_store import SQLiteSharedLinkStore
-                self._store = SQLiteSharedLinkStore(self.config.sqlite_db_path)
-            elif self.config.storage_type == "azure":
-                if not self.config.azure_connection_string:
-                    raise ValueError("Azure connection string is required for Azure storage")
-                from flock.webapp.app.services.sharing_store import AzureTableSharedLinkStore
-                self._store = AzureTableSharedLinkStore(
-                    connection_string=self.config.azure_connection_string,
-                    table_name=self.config.azure_table_name
-                )
-            else:
-                raise ValueError(f"Unsupported storage type: {self.config.storage_type}")
-            
-            await self._store.initialize()
-        
-        return self._store
-    
-    @staticmethod
-    def seed_examples(examples: list["ExampleRecord"]) -> None:
-        """Seed examples into the storage system.
-        
-        Args:
-            examples: List of ExampleRecord objects to seed
-        """
-        import asyncio
-        
-        async def _seed_examples():
-            # Create a default component for seeding
-            component = ExampleUtilityComponent()
-            store = await component._get_store()
-            
-            for example in examples:
-                await store.save_example(example)
-            
-            logger.info(f"Seeded {len(examples)} examples into storage")
-        
-        # Run the async function
-        asyncio.run(_seed_examples())
-    
-    async def _get_relevant_examples(
-        self, 
-        agent_name: str, 
-        inputs: dict[str, Any]
-    ) -> list["ExampleRecord"]:
-        """Get relevant examples for the given agent and inputs."""
-        store = await self._get_store()
-        
-        # Get all examples for this agent
-        all_examples = await store.get_all_examples_for_agent(agent_name)
-        
-        # Filter by timeframe
-        cutoff_date = datetime.utcnow() - timedelta(days=self.config.example_timeframe_days)
-        filtered_examples = [
-            ex for ex in all_examples 
-            if ex.created_at >= cutoff_date
-        ]
-        
-        # Filter by keywords if specified
-        if self.config.example_filter_keywords:
-            filtered_examples = [
-                ex for ex in filtered_examples
-                if any(keyword.lower() in ex.content.lower() for keyword in self.config.example_filter_keywords)
-            ]
-        
-        # Exclude by keywords if specified
-        if self.config.example_exclude_keywords:
-            filtered_examples = [
-                ex for ex in filtered_examples
-                if not any(keyword.lower() in ex.content.lower() for keyword in self.config.example_exclude_keywords)
-            ]
-        
-        # Sort by recency and limit
-        filtered_examples.sort(key=lambda ex: ex.created_at, reverse=True)
-        return filtered_examples[:self.config.max_examples]
-    
-    def _format_examples_for_injection(
-        self, 
-        example_records: list["ExampleRecord"]
-    ) -> str:
-        """Format example records for injection into agent input."""
-        if not example_records:
-            return "No relevant examples available."
-        
-        formatted_parts = []
-        formatted_parts.append(f"Here are {len(example_records)} examples to guide your response:")
-        
-        for i, ex in enumerate(example_records, 1):
-            ex_text = f"\nExample {i} (ID: {ex.example_id}):"
-            ex_text += f"\n{ex.content}"
-            ex_text += f"\nDate: {ex.created_at.strftime('%Y-%m-%d')}"
-            formatted_parts.append(ex_text)
-        
-        return "\n".join(formatted_parts)
-    
-    async def on_pre_evaluate(
-        self,
-        agent: "FlockAgent",
-        inputs: dict[str, Any],
-        context: FlockContext | None = None,
-    ) -> dict[str, Any]:
-        """Inject relevant examples into agent inputs before evaluation."""
-        logger.debug(f"Injecting examples for agent '{agent.name}'")
-        
-        try:
-            # Get relevant examples for this agent
-            example_records = await self._get_relevant_examples(agent.name, inputs)
-            
-            # Format examples for injection
-            formatted_examples = self._format_examples_for_injection(example_records)
-            
-            # Create a copy of inputs to avoid modifying the original
-            enhanced_inputs = inputs.copy()
-            
-            # Inject examples using the configured key
-            enhanced_inputs[self.config.example_input_key] = formatted_examples
-            
-            logger.debug(f"Injected {len(example_records)} examples into '{self.config.example_input_key}'")
-            
-            return enhanced_inputs
-            
-        except Exception as e:
-            logger.error(f"Error injecting examples: {e}")
-            # Return original inputs if example injection fails
-            return inputs
-
-
-# Example record model
-class ExampleRecord:
-    """Record for storing example data."""
-    
-    def __init__(
-        self,
-        agent_name: str,
-        example_id: str,
-        content: str,
-        created_at: datetime | None = None
-    ):
-        self.agent_name = agent_name
-        self.example_id = example_id
-        self.content = content
-        self.created_at = created_at or datetime.utcnow()
-    
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for storage."""
-        return {
-            "agent_name": self.agent_name,
-            "example_id": self.example_id,
-            "content": self.content,
-            "created_at": self.created_at.isoformat(),
-            "context_type": "example"
-        }
-    
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "ExampleRecord":
-        """Create from dictionary from storage."""
-        return cls(
-            agent_name=data["agent_name"],
-            example_id=data["example_id"],
-            content=data["content"],
-            created_at=datetime.fromisoformat(data["created_at"])
-        )

flock/components/utility/feedback_utility_component.py

@@ -1,206 +0,0 @@
-"""Feedback utility component for learning from user feedback."""
-
-from datetime import datetime, timedelta
-from typing import TYPE_CHECKING, Any, Literal
-
-from pydantic import Field
-
-from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.utility_component import UtilityComponent
-from flock.core.context.context import FlockContext
-from flock.core.logging.logging import get_logger
-from flock.core.registry import flock_component
-
-if TYPE_CHECKING:
-    from flock.core.flock_agent import FlockAgent
-    from flock.webapp.app.services.sharing_models import FeedbackRecord
-    from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
-
-logger = get_logger("components.utility.feedback")
-
-
-class FeedbackUtilityConfig(AgentComponentConfig):
-    """Configuration for the FeedbackUtilityComponent."""
-    
-    # Storage configuration
-    storage_type: Literal["sqlite", "azure"] = Field(
-        default="sqlite",
-        description="Type of storage backend for feedback data"
-    )
-    
-    # SQLite configuration
-    sqlite_db_path: str = Field(
-        default="./flock_feedback.db",
-        description="Path to SQLite database file"
-    )
-    
-    # Azure Table Storage configuration
-    azure_connection_string: str | None = Field(
-        default=None,
-        description="Azure Table Storage connection string"
-    )
-    azure_table_name: str = Field(
-        default="flockfeedback",
-        description="Azure Table Storage table name"
-    )
-    
-    # Feedback selection criteria
-    max_feedback_items: int = Field(
-        default=5,
-        description="Maximum number of feedback items to include"
-    )
-    feedback_timeframe_days: int = Field(
-        default=30,
-        description="Only include feedback from the last N days"
-    )
-    
-    # Feedback injection settings
-    feedback_input_key: str = Field(
-        default="feedback_context",
-        description="Input key to use for injected feedback"
-    )
-    include_expected_responses: bool = Field(
-        default=True,
-        description="Whether to include expected responses from feedback"
-    )
-    include_actual_responses: bool = Field(
-        default=False,
-        description="Whether to include actual responses from feedback"
-    )
-    
-    # Feedback filtering
-    feedback_filter_keywords: list[str] = Field(
-        default_factory=list,
-        description="Keywords to filter feedback (only include feedback containing these)"
-    )
-    feedback_exclude_keywords: list[str] = Field(
-        default_factory=list,
-        description="Keywords to exclude feedback containing these"
-    )
-
-
-@flock_component(config_class=FeedbackUtilityConfig)
-class FeedbackUtilityComponent(UtilityComponent):
-    """Utility component that injects relevant feedback into agent inputs."""
-    
-    config: FeedbackUtilityConfig = Field(
-        default_factory=FeedbackUtilityConfig,
-        description="Feedback component configuration"
-    )
-    
-    def __init__(self, name: str = "feedback", config: FeedbackUtilityConfig | None = None, **data):
-        super().__init__(name=name, config=config or FeedbackUtilityConfig(), **data)
-        self._store: SharedLinkStoreInterface | None = None
-    
-    async def _get_store(self) -> SharedLinkStoreInterface:
-        """Get the appropriate feedback store based on configuration."""
-        if self._store is None:
-            if self.config.storage_type == "sqlite":
-                from flock.webapp.app.services.sharing_store import SQLiteSharedLinkStore
-                self._store = SQLiteSharedLinkStore(self.config.sqlite_db_path)
-            elif self.config.storage_type == "azure":
-                if not self.config.azure_connection_string:
-                    raise ValueError("Azure connection string is required for Azure storage")
-                from flock.webapp.app.services.sharing_store import AzureTableSharedLinkStore
-                self._store = AzureTableSharedLinkStore(
-                    connection_string=self.config.azure_connection_string,
-                    table_name=self.config.azure_table_name
-                )
-            else:
-                raise ValueError(f"Unsupported storage type: {self.config.storage_type}")
-            
-            await self._store.initialize()
-        
-        return self._store
-    
-    async def _get_relevant_feedback(
-        self, 
-        agent_name: str, 
-        inputs: dict[str, Any]
-    ) -> list["FeedbackRecord"]:
-        """Get relevant feedback for the given agent and inputs."""
-        store = await self._get_store()
-        
-        # Get all feedback for this agent
-        all_feedback = await store.get_all_feedback_records_for_agent(agent_name)
-        
-        # Filter by timeframe
-        cutoff_date = datetime.utcnow() - timedelta(days=self.config.feedback_timeframe_days)
-        filtered_feedback = [
-            fb for fb in all_feedback 
-            if fb.created_at >= cutoff_date
-        ]
-        
-        # Filter by keywords if specified
-        if self.config.feedback_filter_keywords:
-            filtered_feedback = [
-                fb for fb in filtered_feedback
-                if any(keyword.lower() in fb.reason.lower() for keyword in self.config.feedback_filter_keywords)
-            ]
-        
-        # Exclude by keywords if specified
-        if self.config.feedback_exclude_keywords:
-            filtered_feedback = [
-                fb for fb in filtered_feedback
-                if not any(keyword.lower() in fb.reason.lower() for keyword in self.config.feedback_exclude_keywords)
-            ]
-        
-        # Sort by recency and limit
-        filtered_feedback.sort(key=lambda fb: fb.created_at, reverse=True)
-        return filtered_feedback[:self.config.max_feedback_items]
-    
-    def _format_feedback_for_injection(
-        self, 
-        feedback_records: list["FeedbackRecord"]
-    ) -> str:
-        """Format feedback records for injection into agent input."""
-        if not feedback_records:
-            return "No relevant feedback available."
-        
-        formatted_parts = []
-        formatted_parts.append(f"Here are {len(feedback_records)} pieces of relevant feedback from previous interactions:")
-        
-        for i, fb in enumerate(feedback_records, 1):
-            fb_text = f"\n{i}. Feedback: {fb.reason}"
-            
-            if self.config.include_expected_responses and fb.expected_response:
-                fb_text += f"\n   Expected response: {fb.expected_response}"
-            
-            if self.config.include_actual_responses and fb.actual_response:
-                fb_text += f"\n   Actual response: {fb.actual_response}"
-            
-            fb_text += f"\n   Date: {fb.created_at.strftime('%Y-%m-%d')}"
-            formatted_parts.append(fb_text)
-        
-        return "\n".join(formatted_parts)
-    
-    async def on_pre_evaluate(
-        self,
-        agent: "FlockAgent",
-        inputs: dict[str, Any],
-        context: FlockContext | None = None,
-    ) -> dict[str, Any]:
-        """Inject relevant feedback into agent inputs before evaluation."""
-        logger.debug(f"Injecting feedback for agent '{agent.name}'")
-        
-        try:
-            # Get relevant feedback for this agent
-            feedback_records = await self._get_relevant_feedback(agent.name, inputs)
-            
-            # Format feedback for injection
-            formatted_feedback = self._format_feedback_for_injection(feedback_records)
-            
-            # Create a copy of inputs to avoid modifying the original
-            enhanced_inputs = inputs.copy()
-            
-            # Inject feedback using the configured key
-            enhanced_inputs[self.config.feedback_input_key] = formatted_feedback
-            
-            logger.debug(f"Injected {len(feedback_records)} feedback items into '{self.config.feedback_input_key}'")
-            
-            return enhanced_inputs
-            
-        except Exception as e:
-            logger.error(f"Error injecting feedback: {e}")
-            # Return original inputs if feedback injection fails
-            return inputs