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

flock/core/agent/flock_agent_integration.py

@@ -1,260 +0,0 @@
-# src/flock/core/agent/flock_agent_integration.py
-"""Tool and server integration functionality for FlockAgent."""
-
-from collections.abc import Callable
-from functools import wraps
-from inspect import Parameter, signature
-from typing import TYPE_CHECKING, Any, TypeVar, cast
-
-from flock.core.context.context import FlockContext
-from flock.core.logging.logging import get_logger
-from flock.core.mcp.flock_mcp_server import FlockMCPServer
-from pydantic import BaseModel
-from flock.core.registry import get_registry
-from flock.core.serialization.serialization_utils import (
-    _format_type_to_string,
-    collect_pydantic_models,
-)
-
-if TYPE_CHECKING:
-    from flock.core.flock_agent import FlockAgent
-
-logger = get_logger("agent.integration")
-
-R = TypeVar("R", bound=str)
-
-
-def adapt(prop_name: str, fn: Callable[..., R]) -> Callable[[FlockContext], R]:
-    """Coerce *fn* into the canonical ``(ctx: FlockContext) -> str`` form.
-
-    Acceptable signatures
-    ---------------------
-    1. ``() -> str``                           (no parameters)
-    2. ``(ctx: FlockContext) -> str``          (exactly one positional parameter)
-
-    Anything else raises ``TypeError``.
-
-    The wrapper also enforces at runtime that the result is ``str``.
-    """
-    if not callable(fn):
-        raise TypeError(f"{prop_name} must be a callable, got {type(fn).__name__}")
-
-    sig = signature(fn)
-    params = list(sig.parameters.values())
-
-    def _validate_result(res: object) -> R:
-        if not isinstance(res, str):
-            raise TypeError(
-                f"{prop_name} callable must return str, got {type(res).__name__}"
-            )
-        return cast(R, res)
-
-    # ── Case 1: () -> str ────────────────────────────────────────────────────
-    if len(params) == 0:
-
-        @wraps(fn)
-        def _wrapped(ctx: FlockContext) -> R:
-            return _validate_result(fn())
-
-        return _wrapped
-
-    # ── Case 2: (ctx) -> str ────────────────────────────────────────────────
-    if len(params) == 1:
-        p: Parameter = params[0]
-        valid_kind = p.kind in (
-            Parameter.POSITIONAL_ONLY,
-            Parameter.POSITIONAL_OR_KEYWORD,
-        )
-        valid_annotation = p.annotation in (Parameter.empty, FlockContext)
-        has_no_default = p.default is Parameter.empty
-
-        if valid_kind and valid_annotation and has_no_default:
-
-            @wraps(fn)
-            def _wrapped(ctx: FlockContext) -> R:
-                return _validate_result(fn(ctx))  # type: ignore[arg-type]
-
-            return _wrapped
-
-    # ── Anything else: reject ───────────────────────────────────────────────
-    raise TypeError(
-        f"{prop_name} callable must be () -> str or (ctx: FlockContext) -> str; "
-        f"got signature {sig}"
-    )
-
-class FlockAgentIntegration:
-    """Handles tool and server integration for FlockAgent including MCP servers and callable tools."""
-
-    def __init__(self, agent: "FlockAgent"):
-        self.agent = agent
-
-    def _resolve(self, raw: str | Callable[..., str], name: str, ctx: FlockContext | None) -> str | None:
-        # Support Pydantic BaseModel classes (alternative I/O definitions)
-        try:
-            if isinstance(raw, type) and issubclass(raw, BaseModel):
-                return self._build_spec_from_pydantic(raw)
-            # Also support instances directly (use their class schema)
-            if isinstance(raw, BaseModel):
-                return self._build_spec_from_pydantic(type(raw))
-        except Exception:
-            # If introspection failed, fall through to normal handling
-            pass
-
-        if callable(raw):
-            raw = adapt(name, raw)(ctx or FlockContext())
-        return raw
-
-    def _build_spec_from_pydantic(self, model_cls: type[BaseModel]) -> str:
-        """Builds a flock I/O spec string from a Pydantic BaseModel class.
-
-        Format per field: "name: type | description"; description omitted when empty.
-        Also ensures involved Pydantic models are registered in the TypeRegistry
-        so type resolution works when constructing DSPy signatures.
-        """
-        # Proactively register this model and any nested models
-        try:
-            registry = get_registry()
-            registry.register_type(model_cls, name=model_cls.__name__)
-            # Register nested Pydantic models used in type hints
-            if hasattr(model_cls, "model_fields"):
-                for _, f in model_cls.model_fields.items():
-                    ann = getattr(f, "annotation", None)
-                    for m in collect_pydantic_models(ann):
-                        registry.register_type(m, name=m.__name__)
-        except Exception:
-            # Registration best-effort; continue building spec
-            pass
-
-        fields = []
-        # Pydantic v2: class-level model_fields
-        if not hasattr(model_cls, "model_fields") or model_cls.model_fields is None:  # type: ignore[attr-defined]
-            return ""
-
-        for name, field in model_cls.model_fields.items():  # type: ignore[attr-defined]
-            type_hint = getattr(field, "annotation", None)
-            type_str = _format_type_to_string(type_hint) if type_hint is not None else "str"
-            desc = getattr(field, "description", None) or ""
-            if desc:
-                fields.append(f"{name}: {type_str} | {desc}")
-            else:
-                fields.append(f"{name}: {type_str}")
-
-        return ", ".join(fields)
-
-    def resolve_description(self, context: FlockContext | None = None) -> str | None:
-        """Resolve the agent's description, handling callable descriptions."""
-        return self._resolve(self.agent.description_spec, "description", context)
-
-    def resolve_input(self, context: FlockContext | None = None) -> str | None:
-        """Resolve the agent's input, handling callable inputs."""
-        return self._resolve(self.agent.input_spec, "input", context)
-
-    def resolve_output(self, context: FlockContext | None = None) -> str | None:
-        """Resolve the agent's output, handling callable outputs."""
-        return self._resolve(self.agent.output_spec, "output", context)
-
-    def resolve_next_agent(self, context: FlockContext | None = None) -> str | None:
-        """Resolve the next agent, handling callable next agents."""
-        return self._resolve(self.agent.next_agent_spec, "next_agent", context)
-
-    async def get_mcp_tools(self) -> list[Any]:
-        """Get tools from registered MCP servers."""
-        mcp_tools = []
-        if self.agent.servers:
-            from flock.core.registry import get_registry
-
-            registry = get_registry()  # Get the registry
-            for server in self.agent.servers:
-                registered_server: FlockMCPServer | None = None
-                server_tools = []
-                if isinstance(server, FlockMCPServer):
-                    # check if registered
-                    server_name = server.config.name
-                    registered_server = registry.get_server(
-                        server_name
-                    )
-                else:
-                    # servers must be registered.
-                    registered_server = registry.get_server(
-                        name=server
-                    )
-                if registered_server:
-                    server_tools = await registered_server.get_tools(
-                        agent_id=self.agent.agent_id,
-                        run_id=self.agent.context.run_id,
-                    )
-                else:
-                    logger.warning(
-                        f"No Server with name '{server.config.name if isinstance(server, FlockMCPServer) else server}' registered! Skipping."
-                    )
-                mcp_tools = mcp_tools + server_tools
-        return mcp_tools
-
-    async def execute_with_middleware(
-        self,
-        current_inputs: dict[str, Any],
-        registered_tools: list[Any],
-        mcp_tools: list[Any]
-    ) -> dict[str, Any]:
-        """Execute evaluator with optional DI middleware pipeline."""
-        container = None
-        if self.agent.context is not None:
-            container = self.agent.context.get_variable("di.container")
-
-        # If a MiddlewarePipeline is registered in DI, wrap the evaluator
-        result: dict[str, Any] | None = None
-
-        if container is not None:
-            try:
-                from wd.di.middleware import (
-                    MiddlewarePipeline,
-                )
-
-                pipeline: MiddlewarePipeline | None = None
-                try:
-                    pipeline = container.get_service(MiddlewarePipeline)
-                except Exception:
-                    pipeline = None
-
-                if pipeline is not None:
-                    # Build execution chain where the evaluator is the terminal handler
-
-                    async def _final_handler():
-                        return await self.agent.evaluator.evaluate_core(
-                            self.agent, current_inputs, self.agent.context, registered_tools, mcp_tools
-                        )
-
-                    idx = 0
-
-                    async def _invoke_next():
-                        nonlocal idx
-
-                        if idx < len(pipeline._middleware):
-                            mw = pipeline._middleware[idx]
-                            idx += 1
-                            return await mw(self.agent.context, _invoke_next)  # type: ignore[arg-type]
-                        return await _final_handler()
-
-                    # Execute pipeline
-                    result = await _invoke_next()
-                else:
-                    # No pipeline registered, direct evaluation
-                    result = await self.agent.evaluator.evaluate_core(
-                        self.agent, current_inputs, self.agent.context, registered_tools, mcp_tools
-                    )
-            except ImportError:
-                # wd.di not installed – fall back
-                result = await self.agent.evaluator.evaluate_core(
-                    self.agent, current_inputs, self.agent.context, registered_tools, mcp_tools
-                )
-        else:
-            # No DI container – standard execution
-            result = await self.agent.evaluator.evaluate_core(
-                self.agent,
-                current_inputs,
-                self.agent.context,
-                registered_tools,
-                mcp_tools,
-            )
-
-        return result

flock/core/agent/flock_agent_lifecycle.py

@@ -1,186 +0,0 @@
-# src/flock/core/agent/flock_agent_lifecycle.py
-"""Lifecycle management functionality for FlockAgent."""
-
-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.lifecycle")
-tracer = trace.get_tracer(__name__)
-
-
-class FlockAgentLifecycle:
-    """Handles lifecycle management for FlockAgent including initialization, evaluation, and termination."""
-
-    def __init__(self, agent: "FlockAgent"):
-        self.agent = agent
-
-    async def initialize(self, inputs: dict[str, Any]) -> None:
-        """Initialize agent and run module initializers."""
-        logger.debug(f"Initializing agent '{self.agent.name}'")
-        with tracer.start_as_current_span("agent.initialize") as span:
-            span.set_attribute("agent.name", self.agent.name)
-            span.set_attribute("inputs", str(inputs))
-            logger.info(
-                f"agent.initialize",
-                agent=self.agent.name,
-            )
-            try:
-                for component in self.agent.get_enabled_components():
-                    await component.on_initialize(self.agent, inputs, self.agent.context)
-            except Exception as component_error:
-                logger.error(
-                    "Error during initialize",
-                    agent=self.agent.name,
-                    error=str(component_error),
-                )
-                span.record_exception(component_error)
-
-    async def terminate(
-        self, inputs: dict[str, Any], result: dict[str, Any]
-    ) -> None:
-        """Terminate agent and run module terminators."""
-        logger.debug(f"Terminating agent '{self.agent.name}'")
-        with tracer.start_as_current_span("agent.terminate") as span:
-            span.set_attribute("agent.name", self.agent.name)
-            span.set_attribute("inputs", str(inputs))
-            span.set_attribute("result", str(result))
-            logger.info(
-                f"agent.terminate",
-                agent=self.agent.name,
-            )
-            try:
-                current_result = result
-                for component in self.agent.get_enabled_components():
-                    tmp_result = await component.on_terminate(
-                        self.agent, inputs, self.agent.context, current_result
-                    )
-                    # If the component returns a result, use it
-                    if tmp_result:
-                        current_result = tmp_result
-
-                if self.agent.config.write_to_file:
-                    self.agent._serialization._save_output(self.agent.name, current_result)
-
-                if self.agent.config.wait_for_input:
-                    # simple input prompt
-                    input("Press Enter to continue...")
-
-            except Exception as component_error:
-                logger.error(
-                    "Error during terminate",
-                    agent=self.agent.name,
-                    error=str(component_error),
-                )
-                span.record_exception(component_error)
-
-    async def on_error(self, error: Exception, inputs: dict[str, Any]) -> None:
-        """Handle errors and run component error handlers."""
-        logger.error(f"Error occurred in agent '{self.agent.name}': {error}")
-        with tracer.start_as_current_span("agent.on_error") as span:
-            span.set_attribute("agent.name", self.agent.name)
-            span.set_attribute("inputs", str(inputs))
-            try:
-                for component in self.agent.get_enabled_components():
-                    await component.on_error(self.agent, inputs, self.agent.context, error)
-            except Exception as component_error:
-                logger.error(
-                    "Error during on_error",
-                    agent=self.agent.name,
-                    error=str(component_error),
-                )
-                span.record_exception(component_error)
-
-    async def evaluate(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Core evaluation logic, calling the assigned evaluator and components."""
-        if not self.agent.evaluator:
-            raise RuntimeError(
-                f"Agent '{self.agent.name}' has no evaluator assigned."
-            )
-        with tracer.start_as_current_span("agent.evaluate") as span:
-            span.set_attribute("agent.name", self.agent.name)
-            span.set_attribute("inputs", str(inputs))
-            logger.info(
-                f"agent.evaluate",
-                agent=self.agent.name,
-            )
-
-            logger.debug(f"Evaluating agent '{self.agent.name}'")
-            current_inputs = inputs
-
-            # Pre-evaluate hooks
-            for component in self.agent.get_enabled_components():
-                current_inputs = await component.on_pre_evaluate(
-                    self.agent, current_inputs, self.agent.context
-                )
-
-            # Actual evaluation
-            try:
-                # Get tools and MCP tools through integration handler
-                registered_tools = []
-                if self.agent.tools:
-                    registered_tools = self.agent.tools
-
-                # Retrieve available mcp_tools if the evaluator needs them
-                mcp_tools = []
-                if self.agent.servers:
-                    mcp_tools = await self.agent._integration.get_mcp_tools()
-
-                # Filter tools based on the agent's whitelist (if it has been provided)
-                if self.agent.tool_whitelist is not None and len(self.agent.tool_whitelist) > 0:
-                    for tool in mcp_tools:
-                        if hasattr(tool, "name") and tool.name not in self.agent.tool_whitelist:
-                            mcp_tools.remove(tool)
-                    for tool in registered_tools:
-                        if hasattr(tool, "__name__") and tool.__name__ not in self.agent.tool_whitelist:
-                            registered_tools.remove(tool)
-
-                # --------------------------------------------------
-                # Use evaluator component's evaluate_core method
-                # --------------------------------------------------
-                result = await self.agent.evaluator.evaluate_core(
-                    self.agent, current_inputs, self.agent.context, registered_tools, mcp_tools
-                )
-
-            except Exception as eval_error:
-                logger.error(
-                    "Error during evaluate",
-                    agent=self.agent.name,
-                    error=str(eval_error),
-                )
-                span.record_exception(eval_error)
-                await self.on_error(
-                    eval_error, current_inputs
-                )  # Call error hook
-                raise  # Re-raise the exception
-
-            # Post-evaluate hooks
-            current_result = result
-            for component in self.agent.get_enabled_components():
-                tmp_result = await component.on_post_evaluate(
-                    self.agent,
-                    current_inputs,
-                    self.agent.context,
-                    current_result,
-                )
-                # If the component returns a result, use it
-                if tmp_result:
-                    current_result = tmp_result
-
-            # Handle routing logic
-            router = self.agent.router
-            if router:
-                try:
-                    self.agent.next_agent = await router.determine_next_step(
-                        self.agent, current_result, self.agent.context
-                    )
-                except Exception as e:
-                    logger.error(f"Error in routing: {e}")
-
-            logger.debug(f"Evaluation completed for agent '{self.agent.name}'")
-            return current_result