flock-core 0.5.0b27__py3-none-any.whl → 0.5.0b50__py3-none-any.whl

flock/config.py

@@ -1,61 +0,0 @@
-"""Global configuration for Flock.
-
-Reads environment via `decouple` and exposes constants used across the codebase.
-"""
-
-# flock/config.py
-import os
-
-from decouple import config
-
-from flock.core.logging.telemetry import TelemetryConfig
-
-cfg_file = os.path.expanduser(f"~/.flock/flock.cfg")
-
-
-# -- Connection and External Service Configurations --
-TEMPORAL_SERVER_URL = config("TEMPORAL_SERVER_URL", "localhost:7233")
-DEFAULT_MODEL = config("DEFAULT_MODEL", "openai/gpt-4o")
-
-
-# API Keys and related settings
-TAVILY_API_KEY = config("TAVILY_API_KEY", "")
-GITHUB_PAT = config("GITHUB_PAT", "")
-GITHUB_REPO = config("GITHUB_REPO", "")
-GITHUB_USERNAME = config("GITHUB_USERNAME", "")
-
-# -- Debugging and Logging Configurations --
-LOCAL_DEBUG = config("LOCAL_DEBUG", True)
-LOG_LEVEL = config("LOG_LEVEL", "DEBUG")
-LOGGING_DIR = config("LOGGING_DIR", ".flock/logs")
-
-OTEL_SERVICE_NAME = config("OTL_SERVICE_NAME", "otel-flock")
-JAEGER_ENDPOINT = config(
-    "JAEGER_ENDPOINT", "http://localhost:14268/api/traces"
-)  # Default gRPC endpoint for Jaeger
-JAEGER_TRANSPORT = config(
-    "JAEGER_TRANSPORT", "http"
-).lower()  # Options: "grpc" or "http"
-OTEL_SQL_DATABASE_NAME = config("OTEL_SQL_DATABASE", "flock_events.db")
-OTEL_FILE_NAME = config("OTEL_FILE_NAME", "flock_events.jsonl")
-OTEL_ENABLE_SQL: bool = config("OTEL_ENABLE_SQL", True) == "True"
-OTEL_ENABLE_FILE: bool = config("OTEL_ENABLE_FILE", True) == "True"
-OTEL_ENABLE_JAEGER: bool = config("OTEL_ENABLE_JAEGER", False) == "True"
-OTEL_ENABLE_OTLP: bool = config("OTEL_ENABLE_OTLP", False) == "True"
-OTEL_EXPORTER_OTLP_PROTOCOL: str = config("OTEL_EXPORTER_OTLP_PROTOCOL", "grpc")
-OTEL_EXPORTER_OTLP_ENDPOINT: str = config("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317")
-
-TELEMETRY = TelemetryConfig(
-    OTEL_SERVICE_NAME,
-    JAEGER_ENDPOINT,
-    JAEGER_TRANSPORT,
-    LOGGING_DIR,
-    OTEL_FILE_NAME,
-    OTEL_SQL_DATABASE_NAME,
-    OTEL_ENABLE_JAEGER,
-    OTEL_ENABLE_FILE,
-    OTEL_ENABLE_SQL,
-    OTEL_ENABLE_OTLP,
-    OTEL_EXPORTER_OTLP_PROTOCOL,
-    OTEL_EXPORTER_OTLP_ENDPOINT,
-)

flock/core/__init__.py

@@ -1,110 +0,0 @@
-"""Core package public API with lazy imports.
-
-This module exposes key symbols while avoiding heavy imports at package import time.
-Symbols are imported lazily on first access via ``__getattr__``.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-__all__ = [
-    "Flock",
-    "FlockAgent",
-    "DefaultAgent",
-    "FlockContext",
-    "FlockFactory",
-    # Components
-    "AgentComponent",
-    "AgentComponentConfig",
-    "EvaluationComponent",
-    "RoutingComponent",
-    "UtilityComponent",
-    # MCP
-    "FlockMCPClient",
-    "FlockMCPClientManager",
-    "FlockMCPServer",
-    "FlockMCPTool",
-    # Registry
-    "FlockRegistry",
-    "flock_callable",
-    "flock_component",
-    "flock_tool",
-    "flock_type",
-    "get_registry",
-]
-
-
-def __getattr__(name: str) -> Any:  # pragma: no cover - thin loader
-    if name == "Flock":
-        from .flock import Flock
-
-        return Flock
-    if name == "FlockAgent":
-        from .flock_agent import FlockAgent
-
-        return FlockAgent
-    if name == "DefaultAgent":
-        from .agent.default_agent import DefaultAgent
-
-        return DefaultAgent
-    if name == "FlockContext":
-        from .context.context import FlockContext
-
-        return FlockContext
-    if name == "FlockFactory":
-        from .flock_factory import FlockFactory
-
-        return FlockFactory
-    if name in {"AgentComponent", "AgentComponentConfig", "EvaluationComponent", "RoutingComponent", "UtilityComponent"}:
-        from .component import (
-            AgentComponent,
-            AgentComponentConfig,
-            EvaluationComponent,
-            RoutingComponent,
-            UtilityComponent,
-        )
-
-        return {
-            "AgentComponent": AgentComponent,
-            "AgentComponentConfig": AgentComponentConfig,
-            "EvaluationComponent": EvaluationComponent,
-            "RoutingComponent": RoutingComponent,
-            "UtilityComponent": UtilityComponent,
-        }[name]
-    if name in {"FlockMCPClient", "FlockMCPClientManager", "FlockMCPServer", "FlockMCPTool"}:
-        if name == "FlockMCPClient":
-            from .mcp.mcp_client import FlockMCPClient
-
-            return FlockMCPClient
-        if name == "FlockMCPClientManager":
-            from .mcp.mcp_client_manager import FlockMCPClientManager
-
-            return FlockMCPClientManager
-        if name == "FlockMCPServer":
-            from .mcp.flock_mcp_server import FlockMCPServer
-
-            return FlockMCPServer
-        if name == "FlockMCPTool":
-            from .mcp.flock_mcp_tool import FlockMCPTool
-
-            return FlockMCPTool
-    if name in {"FlockRegistry", "flock_callable", "flock_component", "flock_tool", "flock_type", "get_registry"}:
-        from .registry import (
-            RegistryHub as FlockRegistry,
-            flock_callable,
-            flock_component,
-            flock_tool,
-            flock_type,
-            get_registry,
-        )
-
-        return {
-            "FlockRegistry": FlockRegistry,
-            "flock_callable": flock_callable,
-            "flock_component": flock_component,
-            "flock_tool": flock_tool,
-            "flock_type": flock_type,
-            "get_registry": get_registry,
-        }[name]
-    raise AttributeError(name)

flock/core/agent/__init__.py

@@ -1,16 +0,0 @@
-# src/flock/core/agent/__init__.py
-"""Agent components package."""
-
-from .flock_agent_components import FlockAgentComponents
-from .flock_agent_execution import FlockAgentExecution
-from .flock_agent_integration import FlockAgentIntegration
-from .flock_agent_lifecycle import FlockAgentLifecycle
-from .flock_agent_serialization import FlockAgentSerialization
-
-__all__ = [
-    "FlockAgentComponents",
-    "FlockAgentExecution", 
-    "FlockAgentIntegration",
-    "FlockAgentLifecycle",
-    "FlockAgentSerialization",
-]

flock/core/agent/default_agent.py

@@ -1,180 +0,0 @@
-"""DefaultAgent: explicit preset agent wiring standard components.
-
-This class replaces the need for using FlockFactory for common setups by
-providing a clear, explicit Agent class that mirrors the factory's kwargs
-and composes the standard components under the hood.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any, Literal
-
-from flock.components.utility.metrics_utility_component import (
-    MetricsUtilityComponent,
-    MetricsUtilityConfig,
-)
-from flock.core.config.flock_agent_config import FlockAgentConfig
-from flock.core.flock_agent import DynamicStr, FlockAgent
-from flock.core.logging.formatters.themes import OutputTheme
-from flock.core.mcp.flock_mcp_server import FlockMCPServer
-from flock.workflow.temporal_config import TemporalActivityConfig
-
-
-class DefaultAgent(FlockAgent):
-    """Explicit agent class wiring standard evaluation + utility components.
-
-    Components included:
-    - DeclarativeEvaluationComponent (LLM evaluation)
-    - OutputUtilityComponent (formatting/printing)
-    - MetricsUtilityComponent (latency tracking)
-    """
-
-    def __init__(
-        self,
-        name: str,
-        description: DynamicStr | None = None,
-        model: str | None = None,
-        input: DynamicStr | None = None,
-        output: DynamicStr | None = None,
-        tools: list[Callable[..., Any] | Any] | None = None,
-        servers: list[str | FlockMCPServer] | None = None,
-        tool_whitelist: list[str] | None = None,
-        # Evaluation parameters
-        use_cache: bool = False,
-        temperature: float = 0.7,
-        max_tokens: int | None = None,
-        max_tool_calls: int = 10,
-        max_retries: int = 2,
-        stream: bool = True,
-        stream_callbacks: list[Callable[..., Any] | Any] | None = None,
-        stream_vertical_overflow: Literal["crop", "ellipsis", "crop_above", "visible"] = "crop_above",
-        include_thought_process: bool = False,
-        include_reasoning: bool = False,
-        include_status_output: bool = False,
-        # Output utility parameters
-        enable_rich_tables: bool = True,
-        output_theme: OutputTheme | None = None,
-        no_output: bool = False,
-        print_context: bool = False,
-        # Agent config
-        write_to_file: bool = False,
-        wait_for_input: bool = False,
-        # Metrics utility
-        alert_latency_threshold_ms: int = 30_000,
-        # Workflow
-        next_agent: DynamicStr | None = None,
-        temporal_activity_config: TemporalActivityConfig | None = None,
-    ):
-        """Initialize a DefaultAgent with standard components and configuration.
-
-        Args:
-            name: Unique identifier for the agent
-            description: Human-readable description of the agent's purpose
-            model: Model identifier (e.g., 'openai/gpt-4o'). Uses Flock default if None
-            input: Input signature for the agent
-            output: Output signature for the agent
-            tools: List of callable tools the agent can use
-            servers: List of MCP servers the agent can connect to
-            tool_whitelist: List of tool names that this agent is allowed to use.
-                          If provided, the agent will only have access to tools
-                          whose names are in this list. This applies to both native
-                          Python tools and MCP tools. Recommended for security and
-                          to prevent tool conflicts in multi-agent workflows.
-            use_cache: Whether to enable caching for evaluation
-            temperature: Sampling temperature for LLM generation
-            max_tokens: Maximum tokens for LLM response
-            max_tool_calls: Maximum number of tool calls per evaluation
-            max_retries: Maximum retries for failed LLM calls
-            stream: Whether to enable streaming responses
-            stream_callbacks: Optional callbacks invoked with each streaming chunk
-            stream_vertical_overflow: Rich Live overflow handling ('ellipsis', 'crop', 'crop_above', 'visible')
-            include_thought_process: Include reasoning in output
-            include_reasoning: Include detailed reasoning steps
-            include_status_output: Include status output in output
-            enable_rich_tables: Enable rich table formatting for output
-            output_theme: Theme for output formatting
-            no_output: Disable output printing
-            print_context: Include context in output
-            write_to_file: Save outputs to file
-            wait_for_input: Wait for user input after execution
-            alert_latency_threshold_ms: Threshold for latency alerts
-            next_agent: Next agent in workflow chain
-            temporal_activity_config: Configuration for Temporal workflow execution
-        """
-        # Import evaluation/output components lazily to avoid heavy imports at module import time
-        from flock.components.evaluation.declarative_evaluation_component import (
-            DeclarativeEvaluationComponent,
-            DeclarativeEvaluationConfig,
-        )
-        from flock.components.utility.output_utility_component import (
-            OutputUtilityComponent,
-            OutputUtilityConfig,
-        )
-
-        # Apply sensible defaults for special models if needed
-        if model and "gpt-oss" in model:
-            # Ensure defaults are generous for local OSS models
-            temperature = 1.0
-            max_tokens = 32_768
-
-        # Evaluation component
-        _eval_kwargs = dict(
-            model=model,
-            use_cache=use_cache,
-            temperature=temperature,
-            max_tool_calls=max_tool_calls,
-            max_retries=max_retries,
-            no_output=no_output,
-            stream=stream,
-            stream_callbacks=stream_callbacks,
-            stream_vertical_overflow=stream_vertical_overflow,
-            include_thought_process=include_thought_process,
-            include_reasoning=include_reasoning,
-            include_status_output=include_status_output,
-        )
-        if max_tokens is not None:
-            _eval_kwargs["max_tokens"] = max_tokens
-        eval_config = DeclarativeEvaluationConfig(**_eval_kwargs)
-        evaluator = DeclarativeEvaluationComponent(
-            name="default_evaluator", config=eval_config
-        )
-
-        # Output utility component
-        _output_kwargs = dict(
-            render_table=enable_rich_tables,
-            no_output=no_output,
-            print_context=print_context,
-        )
-        if output_theme is not None:
-            _output_kwargs["theme"] = output_theme
-        output_config = OutputUtilityConfig(**_output_kwargs)
-        output_component = OutputUtilityComponent(
-            name="output_formatter", config=output_config
-        )
-
-        # Metrics utility component
-        metrics_config = MetricsUtilityConfig(
-            latency_threshold_ms=alert_latency_threshold_ms
-        )
-        metrics_component = MetricsUtilityComponent(
-            name="metrics_tracker", config=metrics_config
-        )
-
-        super().__init__(
-            name=name,
-            model=model,
-            description=description,
-            input=input,
-            output=output,
-            tools=tools,
-            servers=servers,
-            tool_whitelist=tool_whitelist,
-            components=[evaluator, output_component, metrics_component],
-            config=FlockAgentConfig(
-                write_to_file=write_to_file,
-                wait_for_input=wait_for_input,
-            ),
-            next_agent=next_agent,
-            temporal_activity_config=temporal_activity_config,
-        )

flock/core/agent/flock_agent_components.py

@@ -1,104 +0,0 @@
-"""Component management functionality for FlockAgent."""
-
-from typing import TYPE_CHECKING, Any
-
-from flock.core.component.evaluation_component import EvaluationComponent
-from flock.core.component.routing_component import RoutingComponent
-from flock.core.component.utility_component import UtilityComponent
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.component.agent_component_base import AgentComponent
-    from flock.core.flock_agent import FlockAgent
-
-logger = get_logger("agent.components")
-
-
-class FlockAgentComponents:
-    """Helper class for managing unified components on FlockAgent."""
-
-    def __init__(self, agent: "FlockAgent"):
-        self.agent = agent
-
-    def add_component(self, component: "AgentComponent") -> None:
-        """Add a unified component to this agent."""
-        if not component.name:
-            logger.error("Component must have a name to be added.")
-            return
-
-        # Check if component with same name already exists
-        existing = self.get_component(component.name)
-        if existing:
-            logger.warning(f"Overwriting existing component: {component.name}")
-            self.agent.components.remove(existing)
-
-        self.agent.components.append(component)
-        logger.debug(f"Added component '{component.name}' to agent '{self.agent.name}'")
-
-    def remove_component(self, component_name: str) -> None:
-        """Remove a component from this agent."""
-        component = self.get_component(component_name)
-        if component:
-            self.agent.components.remove(component)
-            logger.debug(f"Removed component '{component_name}' from agent '{self.agent.name}'")
-        else:
-            logger.warning(f"Component '{component_name}' not found on agent '{self.agent.name}'")
-
-    def get_component(self, component_name: str) -> "AgentComponent | None":
-        """Get a component by name."""
-        for component in self.agent.components:
-            if component.name == component_name:
-                return component
-        return None
-
-    def get_enabled_components(self) -> list["AgentComponent"]:
-        """Get a list of currently enabled components attached to this agent."""
-        return [c for c in self.agent.components if c.config.enabled]
-
-    def get_components_by_type(self, component_type: type) -> list["AgentComponent"]:
-        """Get all components of a specific type."""
-        return [c for c in self.agent.components if isinstance(c, component_type)]
-
-    def get_evaluation_components(self) -> list[EvaluationComponent]:
-        """Get all evaluation components."""
-        return self.get_components_by_type(EvaluationComponent)
-
-    def get_routing_components(self) -> list[RoutingComponent]:
-        """Get all routing components."""
-        return self.get_components_by_type(RoutingComponent)
-
-    def get_utility_components(self) -> list[UtilityComponent]:
-        """Get all utility components."""
-        return self.get_components_by_type(UtilityComponent)
-
-    def get_primary_evaluator(self) -> EvaluationComponent | None:
-        """Get the primary evaluation component (first one found)."""
-        evaluators = self.get_evaluation_components()
-        return evaluators[0] if evaluators else None
-
-    def get_primary_router(self) -> RoutingComponent | None:
-        """Get the primary routing component (first one found)."""
-        routers = self.get_routing_components()
-        return routers[0] if routers else None
-
-    # Legacy compatibility methods (delegate to new unified approach)
-    def add_module(self, module: Any) -> None:
-        """DEPRECATED: Use add_component() instead."""
-        logger.warning("add_module is deprecated - use add_component() instead")
-        if hasattr(module, 'name'):
-            self.add_component(module)
-
-    def get_module(self, module_name: str) -> Any | None:
-        """DEPRECATED: Use get_component() instead."""
-        logger.warning("get_module is deprecated - use get_component() instead")
-        return self.get_component(module_name)
-
-    def get_evaluator(self) -> Any | None:
-        """DEPRECATED: Use get_primary_evaluator() instead."""
-        logger.warning("get_evaluator is deprecated - use get_primary_evaluator() instead")
-        return self.get_primary_evaluator()
-
-    def get_router(self) -> Any | None:
-        """DEPRECATED: Use get_primary_router() instead."""
-        logger.warning("get_router is deprecated - use get_primary_router() instead")
-        return self.get_primary_router()

flock/core/agent/flock_agent_execution.py

@@ -1,101 +0,0 @@
-# src/flock/core/agent/flock_agent_execution.py
-"""Execution management functionality for FlockAgent."""
-
-import asyncio
-from typing import TYPE_CHECKING, Any
-
-from opentelemetry import trace
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.flock_agent import FlockAgent
-
-logger = get_logger("agent.execution")
-tracer = trace.get_tracer(__name__)
-
-
-class FlockAgentExecution:
-    """Handles execution management for FlockAgent including run, run_async, and run_temporal."""
-
-    def __init__(self, agent: "FlockAgent"):
-        self.agent = agent
-
-    def run(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Synchronous wrapper for run_async."""
-        try:
-            loop = asyncio.get_running_loop()
-        except (
-            RuntimeError
-        ):  # 'RuntimeError: There is no current event loop...'
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        return loop.run_until_complete(self.run_async(inputs))
-
-    async def run_async(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Asynchronous execution logic with lifecycle hooks."""
-        with tracer.start_as_current_span("agent.run") as span:
-            span.set_attribute("agent.name", self.agent.name)
-            span.set_attribute("inputs", str(inputs))
-            try:
-                # Initialize lifecycle system if not already present
-                if not hasattr(self.agent, '_lifecycle'):
-                    from flock.core.agent.flock_agent_lifecycle import FlockAgentLifecycle
-                    self.agent._lifecycle = FlockAgentLifecycle(self.agent)
-                    
-                await self.agent._lifecycle.initialize(inputs)
-                result = await self.agent._lifecycle.evaluate(inputs)
-                await self.agent._lifecycle.terminate(inputs, result)
-                span.set_attribute("result", str(result))
-                logger.info("Agent run completed", agent=self.agent.name)
-                return result
-            except Exception as run_error:
-                logger.error(
-                    "Error running agent", agent=self.agent.name, error=str(run_error)
-                )
-                if "evaluate" not in str(
-                    run_error
-                ):  # Simple check, might need refinement
-                    await self.agent._lifecycle.on_error(run_error, inputs)
-                logger.error(
-                    f"Agent '{self.agent.name}' run failed: {run_error}",
-                    exc_info=True,
-                )
-                span.record_exception(run_error)
-                raise  # Re-raise after handling
-
-    async def run_temporal(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Execute agent using Temporal workflow orchestration."""
-        with tracer.start_as_current_span("agent.run_temporal") as span:
-            span.set_attribute("agent.name", self.agent.name)
-            span.set_attribute("inputs", str(inputs))
-            try:
-                from temporalio.client import Client
-
-                from flock.workflow.agent_activities import (
-                    run_flock_agent_activity,
-                )
-                from flock.workflow.temporal_setup import run_activity
-
-                client = await Client.connect(
-                    "localhost:7233", namespace="default"
-                )
-                agent_data = self.agent._serialization.to_dict()
-                inputs_data = inputs
-
-                result = await run_activity(
-                    client,
-                    self.agent.name,
-                    run_flock_agent_activity,
-                    {"agent_data": agent_data, "inputs": inputs_data},
-                )
-                span.set_attribute("result", str(result))
-                logger.info("Temporal run successful", agent=self.agent.name)
-                return result
-            except Exception as temporal_error:
-                logger.error(
-                    "Error in Temporal workflow",
-                    agent=self.agent.name,
-                    error=str(temporal_error),
-                )
-                span.record_exception(temporal_error)
-                raise