flock-core 0.4.527__py3-none-any.whl → 0.5.0b0__py3-none-any.whl

flock/core/flock_router.py

@@ -1,83 +0,0 @@
-"""Base router class for the Flock framework."""
-
-from abc import ABC, abstractmethod
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field
-
-from flock.core.context.context import FlockContext
-
-
-class HandOffRequest(BaseModel):
-    """Base class for handoff returns."""
-
-    next_agent: str = Field(default="", description="Next agent to invoke")
-    # match = use the output fields of the current agent that also exists as input field of the next agent
-    # add = add the output of the current agent to the input of the next agent
-    output_to_input_merge_strategy: Literal["match", "add"] = Field(
-        default="match"
-    )
-    add_input_fields: list[str] | None = Field(
-        default=None,
-        description="List of input fields to add to the next agent",
-    )
-    add_output_fields: list[str] | None = Field(
-        default=None,
-        description="List of output fields to add to the next agent",
-    )
-    add_description: str | None = Field(
-        default=None, description="Add this description to the next agent"
-    )
-    override_next_agent: Any | None = Field(
-        default=None,
-        description="Override the next agent to hand off to",
-    )
-    override_context: FlockContext | None = Field(
-        default=None, description="Override context parameters"
-    )
-
-
-class FlockRouterConfig(BaseModel):
-    """Configuration for a router.
-
-    This class defines the configuration parameters for a router.
-    Subclasses can extend this to add additional parameters.
-    """
-
-    enabled: bool = Field(
-        default=True, description="Whether the router is enabled"
-    )
-    # agents: list[str] | None = Field(
-    #     default=None,
-    #     description="List of agents to choose from",
-    # )
-
-
-class FlockRouter(BaseModel, ABC):
-    """Base class for all routers.
-
-    A router is responsible for determining the next agent in a workflow
-    based on the current agent's output.
-    """
-
-    name: str = Field(..., description="Name of the router")
-    config: FlockRouterConfig = Field(default_factory=FlockRouterConfig)
-
-    @abstractmethod
-    async def route(
-        self,
-        current_agent: Any,
-        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
-        """
-        pass

flock/evaluators/__init__.py

@@ -1 +0,0 @@
-# Package for modules

flock/evaluators/declarative/__init__.py

@@ -1 +0,0 @@
-# Package for modules

flock/evaluators/declarative/declarative_evaluator.py

@@ -1,217 +0,0 @@
-from collections.abc import Generator
-from typing import Any
-
-from temporalio import workflow
-
-with workflow.unsafe.imports_passed_through():
-    import dspy
-
-from pydantic import Field, PrivateAttr
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_registry import flock_component
-from flock.core.logging.logging import get_logger
-from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
-from flock.core.mixin.prompt_parser import PromptParserMixin
-
-logger = get_logger("evaluators.declarative")
-
-
-class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
-    """Configuration for the DeclarativeEvaluator."""
-
-    override_evaluator_type: str | None = None
-    model: str | None = "openai/gpt-4o"
-    use_cache: bool = True
-    temperature: float = 0.0
-    max_tokens: int = 4096
-    max_retries: int = 3
-    max_tool_calls: int = 10
-    stream: bool = Field(
-        default=False,
-        description="Enable streaming output from the underlying DSPy program.",
-    )
-    include_thought_process: bool = Field(
-        default=False,
-        description="Include the thought process in the output.",
-    )
-    include_reasoning: bool = Field(
-        default=False,
-        description="Include the reasoning in the output.",
-    )
-    kwargs: dict[str, Any] = Field(default_factory=dict)
-
-
-@flock_component(config_class=DeclarativeEvaluatorConfig)
-class DeclarativeEvaluator(
-    FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin
-):
-    """Evaluator that uses DSPy for generation."""
-
-    config: DeclarativeEvaluatorConfig = Field(
-        default_factory=DeclarativeEvaluatorConfig,
-        description="Evaluator configuration",
-    )
-
-    _cost: float = PrivateAttr(default=0.0)
-    _lm_history: list = PrivateAttr(default_factory=list)
-
-    # def __init__(self, name: str, config: DeclarativeEvaluatorConfig) -> None:
-    #     super().__init__(name=name, config=config)
-    # self._configure_language_model(
-    #     model=config.model,
-    #     use_cache=config.use_cache,
-    #     temperature=config.temperature,
-    #     max_tokens=config.max_tokens,
-    # )
-
-    async def evaluate(
-        self,
-        agent: FlockAgent,
-        inputs: dict[str, Any],
-        tools: list[Any],
-        mcp_tools: list[Any] | None = None,
-    ) -> dict[str, Any]:
-        """Evaluate using DSPy, with optional asynchronous streaming."""
-        # --- Setup Signature and LM ---
-
-        with dspy.context(
-            lm=dspy.LM(
-                model=self.config.model or agent.model,
-                cache=self.config.use_cache,
-                temperature=self.config.temperature,
-                max_tokens=self.config.max_tokens,
-                num_retries=self.config.max_retries,
-            )
-        ):
-            try:
-                from rich.console import Console
-
-                console = Console()
-                _dspy_signature = self.create_dspy_signature_class(
-                    agent.name,
-                    agent.description,
-                    f"{agent.input} -> {agent.output}",
-                )
-                # --- Get output field names ---
-                # dspy.Signature holds fields in .output_fields attribute
-                output_field_names = list(_dspy_signature.output_fields.keys())
-                if not output_field_names:
-                    logger.warning(
-                        f"DSPy signature for agent '{agent.name}' has no defined output fields. Streaming might not produce text."
-                    )
-                # -----------------------------
-
-                agent_task = self._select_task(
-                    _dspy_signature,
-                    override_evaluator_type=self.config.override_evaluator_type,
-                    tools=tools,
-                    max_tool_calls=self.config.max_tool_calls,
-                    mcp_tools=mcp_tools,
-                    kwargs=self.config.kwargs,
-                )
-            except Exception as setup_error:
-                logger.error(
-                    f"Error setting up DSPy task for agent '{agent.name}': {setup_error}",
-                    exc_info=True,
-                )
-                raise RuntimeError(
-                    f"DSPy task setup failed: {setup_error}"
-                ) from setup_error
-
-            # --- Conditional Evaluation (Stream vs No Stream) ---
-            if self.config.stream:
-                logger.info(
-                    f"Evaluating agent '{agent.name}' with async streaming."
-                )
-                if not callable(agent_task):
-                    logger.error("agent_task is not callable, cannot stream.")
-                    raise TypeError(
-                        "DSPy task could not be created or is not callable."
-                    )
-
-                streaming_task = dspy.streamify(
-                    agent_task, is_async_program=True
-                )
-                stream_generator: Generator = streaming_task(**inputs)
-                delta_content = ""
-
-                console.print("\n")
-                async for chunk in stream_generator:
-                    if (
-                        hasattr(chunk, "choices")
-                        and chunk.choices
-                        and hasattr(chunk.choices[0], "delta")
-                        and chunk.choices[0].delta
-                        and hasattr(chunk.choices[0].delta, "content")
-                    ):
-                        delta_content = chunk.choices[0].delta.content
-
-                    if delta_content:
-                        console.print(delta_content, end="")
-
-                    result_dict, cost, lm_history = self._process_result(
-                        chunk, inputs
-                    )
-                    self._cost = cost
-                    self._lm_history = lm_history
-
-                console.print("\n")
-                result_dict = self.filter_reasoning(
-                    result_dict, self.config.include_reasoning
-                )
-                return self.filter_thought_process(
-                    result_dict, self.config.include_thought_process
-                )
-
-            else:  # Non-streaming path
-                logger.info(
-                    f"Evaluating agent '{agent.name}' without streaming."
-                )
-                try:
-                    # Ensure the call is awaited if the underlying task is async
-                    result_obj = await agent_task.acall(**inputs)
-                    result_dict, cost, lm_history = self._process_result(
-                        result_obj, inputs
-                    )
-                    self._cost = cost
-                    self._lm_history = lm_history
-                    result_dict = self.filter_reasoning(
-                        result_dict, self.config.include_reasoning
-                    )
-                    return self.filter_thought_process(
-                        result_dict, self.config.include_thought_process
-                    )
-                except Exception as e:
-                    logger.error(
-                        f"Error during non-streaming evaluation for agent '{agent.name}': {e}",
-                        exc_info=True,
-                    )
-                    raise RuntimeError(f"Evaluation failed: {e}") from e
-
-    def filter_thought_process(
-        self, result_dict: dict[str, Any], include_thought_process: bool
-    ) -> dict[str, Any]:
-        """Filter out thought process from the result dictionary."""
-        if include_thought_process:
-            return result_dict
-        else:
-            return {
-                k: v
-                for k, v in result_dict.items()
-                if not (k.startswith("trajectory"))
-            }
-
-    def filter_reasoning(
-        self, result_dict: dict[str, Any], include_reasoning: bool
-    ) -> dict[str, Any]:
-        """Filter out reasoning from the result dictionary."""
-        if include_reasoning:
-            return result_dict
-        else:
-            return {
-                k: v
-                for k, v in result_dict.items()
-                if not (k.startswith("reasoning"))
-            }

flock/evaluators/memory/memory_evaluator.py

@@ -1,90 +0,0 @@
-from typing import Any, Literal
-
-from pydantic import Field
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_registry import flock_component
-from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
-from flock.core.mixin.prompt_parser import PromptParserMixin
-from flock.modules.memory.memory_module import MemoryModule, MemoryModuleConfig
-
-
-class MemoryEvaluatorConfig(FlockEvaluatorConfig):
-    folder_path: str = Field(
-        default="concept_memory/",
-        description="Directory where memory file and concept graph will be saved",
-    )
-    concept_graph_file: str = Field(
-        default="concept_graph.png",
-        description="Base filename for the concept graph image",
-    )
-
-    file_path: str | None = Field(
-        default="agent_memory.json", description="Path to save memory file"
-    )
-    memory_mapping: str | None = Field(
-        default=None, description="Memory mapping configuration"
-    )
-    similarity_threshold: float = Field(
-        default=0.5, description="Threshold for semantic similarity"
-    )
-    max_length: int = Field(
-        default=1000, description="Max length of memory entry before splitting"
-    )
-    save_after_update: bool = Field(
-        default=True, description="Whether to save memory after each update"
-    )
-    splitting_mode: Literal["summary", "semantic", "characters", "none"] = (
-        Field(default="none", description="Mode to split memory content")
-    )
-    enable_read_only_mode: bool = Field(
-        default=False, description="Whether to enable read only mode"
-    )
-    number_of_concepts_to_extract: int = Field(
-        default=3, description="Number of concepts to extract from the memory"
-    )
-
-
-@flock_component(config_class=MemoryEvaluatorConfig)
-class MemoryEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
-    """Evaluator that uses DSPy for generation."""
-
-    config: MemoryEvaluatorConfig = Field(
-        default_factory=MemoryEvaluatorConfig,
-        description="Evaluator configuration",
-    )
-
-    async def evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
-    ) -> dict[str, Any]:
-        """Simple evaluator that uses a memory concept graph.
-
-        if inputs contain "query", it searches memory for the query and returns the facts.
-        if inputs contain "data", it adds the data to memory
-        """
-        result = {}
-        memory_module = MemoryModule(
-            name=self.name,
-            config=MemoryModuleConfig(
-                folder_path=self.config.folder_path,
-                concept_graph_file=self.config.concept_graph_file,
-                file_path=self.config.file_path,
-                memory_mapping=self.config.memory_mapping,
-                similarity_threshold=self.config.similarity_threshold,
-                max_length=self.config.max_length,
-                save_after_update=self.config.save_after_update,
-                splitting_mode=self.config.splitting_mode,
-                enable_read_only_mode=self.config.enable_read_only_mode,
-                number_of_concepts_to_extract=self.config.number_of_concepts_to_extract,
-            ),
-        )
-
-        if "query" in inputs:
-            facts = await memory_module.search_memory(agent, inputs)
-            result = {"facts": facts}
-
-        if "data" in inputs:
-            await memory_module.add_to_memory(agent, inputs)
-            result = {"message": "Data added to memory"}
-        return result

flock/evaluators/test/test_case_evaluator.py

@@ -1,38 +0,0 @@
-from typing import Any
-
-from pydantic import Field
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_registry import flock_component
-from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
-
-
-class TestCaseEvaluatorConfig(FlockEvaluatorConfig):
-    """Configuration for the TestCaseEvaluator."""
-
-    pass
-
-
-@flock_component(config_class=TestCaseEvaluatorConfig)
-class TestCaseEvaluator(FlockEvaluator, DSPyIntegrationMixin):
-    """Evaluator for test cases."""
-
-    config: TestCaseEvaluatorConfig = Field(
-        default_factory=TestCaseEvaluatorConfig,
-        description="Evaluator configuration",
-    )
-
-    async def evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
-    ) -> dict[str, Any]:
-        _dspy_signature = self.create_dspy_signature_class(
-            agent.name,
-            agent.description,
-            f"{agent.input} -> {agent.output}",
-        )
-        output_field_names = list(_dspy_signature.output_fields.keys())
-        result = {}
-        for output_field_name in output_field_names:
-            result[output_field_name] = "Test Result"
-        return result

flock/evaluators/zep/zep_evaluator.py

@@ -1,59 +0,0 @@
-from typing import Any
-
-from pydantic import Field
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_registry import flock_component
-from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
-from flock.core.mixin.prompt_parser import PromptParserMixin
-from flock.modules.zep.zep_module import ZepModule, ZepModuleConfig
-
-
-class ZepEvaluatorConfig(FlockEvaluatorConfig):
-    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"
-    )
-
-
-@flock_component(config_class=ZepEvaluatorConfig)
-class ZepEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
-    """Evaluator that uses DSPy for generation."""
-
-    config: ZepEvaluatorConfig = Field(
-        default_factory=ZepEvaluatorConfig,
-        description="Evaluator configuration",
-    )
-
-    async def evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
-    ) -> dict[str, Any]:
-        """Simple evaluator that uses Zep.
-
-        if inputs contain "query", it searches memory for the query and returns the facts.
-        if inputs contain "data", it adds the data to memory
-        """
-        result = {}
-        zep = ZepModule(
-            name=self.name,
-            config=ZepModuleConfig(
-                zep_api_key=self.config.zep_api_key,
-                zep_url=self.config.zep_url,
-                min_fact_rating=self.config.min_fact_rating,
-                enable_read=True,
-                enable_write=True,
-            ),
-        )
-        client = zep.get_client()
-        if "query" in inputs:
-            query = inputs["query"]
-            facts = zep.search_memory(query, client)
-            result = {"facts": facts}
-
-        if "data" in inputs:
-            data = inputs["data"]
-            zep.add_to_memory(data, client)
-            result = {"message": "Data added to memory"}
-        return result

flock/modules/__init__.py

@@ -1 +0,0 @@
-# Package for modules

flock/modules/assertion/__init__.py

@@ -1 +0,0 @@
-# Package for modules