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

flock/workflow/activities.py

@@ -1,196 +0,0 @@
-"""Defines Temporal activities for running a chain of agents with logging and tracing."""
-
-from datetime import datetime
-
-from opentelemetry import trace
-from temporalio import activity
-
-from flock.core.context.context import FlockContext
-from flock.core.context.context_vars import FLOCK_CURRENT_AGENT, FLOCK_MODEL
-
-# HandOffRequest removed - using agent.next_agent directly
-from flock.core.logging.logging import get_logger
-from flock.core.registry import get_registry
-from flock.core.util.input_resolver import resolve_inputs
-
-logger = get_logger("activities")
-tracer = trace.get_tracer(__name__)
-
-def apply_handoff_strategy(previous_agent_output:str, next_agent_input:str, previous_agent_handoff_strategy:str, previous_agent_handoff_map:dict[str, str]) -> str:
-    if previous_agent_handoff_strategy == "append":
-        return next_agent_input + previous_agent_output
-    elif previous_agent_handoff_strategy == "override":
-        return previous_agent_output
-    elif previous_agent_handoff_strategy == "static":
-        return next_agent_input
-    elif previous_agent_handoff_strategy == "map":
-        for key, value in previous_agent_handoff_map.items():
-            next_agent_input = next_agent_input.replace(key, value)
-        return next_agent_input
-    raise NotImplementedError
-
-
-@activity.defn
-async def run_agent(context: FlockContext) -> dict:
-    """Runs a chain of agents using the provided context.
-
-    The context contains state, history, and agent definitions.
-    After each agent run, its output is merged into the context.
-    """
-    # Start a top-level span for the entire run_agent activity.
-    with tracer.start_as_current_span("run_agent") as span:
-        registry = get_registry()
-
-        previous_agent_name = ""
-        previous_agent_output = ""
-        previous_agent_handoff_strategy = ""
-        previous_agent_handoff_map = {}
-        if isinstance(context, dict):
-            context = FlockContext.from_dict(context)
-        current_agent_name = context.get_variable(FLOCK_CURRENT_AGENT)
-        span.set_attribute("initial.agent", current_agent_name)
-        logger.info("Starting agent chain", initial_agent=current_agent_name)
-
-        agent = registry.get_agent(current_agent_name)
-        if agent.model is None or agent.evaluator.config.model is None:
-            agent.set_model(context.get_variable(FLOCK_MODEL))
-
-        if not agent:
-            logger.error("Agent not found", agent=current_agent_name)
-            span.record_exception(
-                Exception(f"Agent '{current_agent_name}' not found")
-            )
-            return {"error": f"Agent '{current_agent_name}' not found."}
-
-        # Loop over agents in the chain.
-        while agent:
-            # Create a nested span for this iteration.
-            with tracer.start_as_current_span("agent_iteration") as iter_span:
-                iter_span.set_attribute("agent.name", agent.name)
-                agent.context = context
-                # Resolve inputs for the agent.
-                # Gets values from context, previous agent output, and handoff strategy.
-                agent_inputs = resolve_inputs(
-                    agent.input,
-                    context,
-                    previous_agent_name,
-                    previous_agent_output,
-                    previous_agent_handoff_strategy,
-                    previous_agent_handoff_map
-                )
-                iter_span.add_event(
-                    "resolved inputs", attributes={"inputs": str(agent_inputs)}
-                )
-
-                # Execute the agent with its own span.
-                with tracer.start_as_current_span("execute_agent") as exec_span:
-                    logger.info("Executing agent", agent=agent.name)
-                    try:
-                        result = await agent.run_async(agent_inputs)
-                        exec_span.set_attribute("result", str(result))
-                        logger.debug(
-                            "Agent execution completed", agent=agent.name
-                        )
-                        context.record(
-                            agent.name,
-                            result,
-                            timestamp=datetime.now().isoformat(),
-                            hand_off=None,
-                            called_from=previous_agent_name,
-                        )
-                    except Exception as e:
-                        logger.error(
-                            "Agent execution failed",
-                            agent=agent.name,
-                            error=str(e),
-                        )
-                        exec_span.record_exception(e)
-                        raise
-
-                # Determine the next agent using routing component if available
-                next_agent_name = None
-
-                if agent.router:
-                    logger.info(
-                        f"Using router: {agent.router.__class__.__name__}",
-                        agent=agent.name,
-                    )
-                    try:
-                        # Route to the next agent using new routing component
-                        next_agent_name = await agent.router.determine_next_step(
-                            agent, result, context
-                        )
-
-                        # Set next_agent on the agent instance
-                        agent.next_agent = next_agent_name
-
-                    except Exception as e:
-                        logger.error(
-                            f"Router error: {e}",
-                            agent=agent.name,
-                            error=str(e),
-                        )
-                        iter_span.record_exception(e)
-                        return {"error": f"Router error: {e}"}
-                else:
-                    # Check if next_agent was set directly by user
-                    next_agent_name = agent.next_agent
-                    if callable(next_agent_name):
-                        try:
-                            next_agent_name = next_agent_name(context, result)
-                        except Exception as e:
-                            logger.error(f"next_agent callable error: {e}")
-                            return {"error": f"next_agent callable error: {e}"}
-
-                if not next_agent_name:
-                    logger.info(
-                        "No next agent found, completing chain",
-                        agent=agent.name,
-                    )
-                    iter_span.add_event("chain completed")
-                    return result
-
-                # Record the agent run in the context.
-                context.record(
-                    agent.name,
-                    result,
-                    timestamp=datetime.now().isoformat(),
-                    hand_off={"next_agent": next_agent_name} if next_agent_name else None,
-                    called_from=previous_agent_name,
-                )
-                # Remember the current agent's details for the next iteration.
-                previous_agent_name = agent.name
-                previous_agent_output = agent.output
-                previous_agent_handoff_strategy = agent.config.handoff_strategy
-                previous_agent_handoff_map = agent.config.handoff_map
-
-                # Activate the next agent.
-                try:
-                    agent = registry.get_agent(next_agent_name)
-                    if not agent:
-                        logger.error(
-                            "Next agent not found",
-                            agent=next_agent_name,
-                        )
-                        iter_span.record_exception(
-                            Exception(
-                                f"Next agent '{next_agent_name}' not found"
-                            )
-                        )
-                        return {
-                            "error": f"Next agent '{next_agent_name}' not found."
-                        }
-
-
-
-                    context.set_variable(FLOCK_CURRENT_AGENT, agent.name)
-
-                    logger.info("Handing off to next agent", next=agent.name)
-                    iter_span.set_attribute("next.agent", agent.name)
-                except Exception as e:
-                    logger.error("Error during handoff", error=str(e))
-                    iter_span.record_exception(e)
-                    return {"error": f"Error during handoff: {e}"}
-
-        # If the loop exits unexpectedly, return the initial input.
-        return context.get_variable("init_input")

flock/workflow/agent_activities.py

@@ -1,24 +0,0 @@
-from temporalio import activity
-
-from flock.core.context.context import FlockContext
-from flock.core.flock_agent import FlockAgent
-
-
-@activity.defn
-async def run_declarative_agent_activity(params: dict) -> dict:
-    """Temporal activity to run a declarative (or batch) agent.
-
-    Expects a dictionary with:
-      - "agent_data": a dict representation of the agent (as produced by .dict()),
-      - "context_data": a dict containing the FlockContext state and optionally other fields.
-
-    The activity reconstructs the agent and a FlockContext, then calls the agent’s _evaluate() method.
-    """
-    agent_data = params.get("agent_data")
-    context_data = params.get("context_data", {})
-    # Reconstruct the agent from its serialized representation.
-    agent = FlockAgent.from_dict(agent_data)
-    # Reconstruct the FlockContext from the state.
-    context = FlockContext.from_dict(context_data)
-    result = await agent.evaluate(context)
-    return result

flock/workflow/agent_execution_activity.py

@@ -1,202 +0,0 @@
-"""Defines granular Temporal activities for executing a single agent
-and determining the next agent in a Flock workflow.
-"""
-
-from collections.abc import Callable
-
-from opentelemetry import trace
-from temporalio import activity
-
-# Third-party imports only within activity functions if needed, or pass context
-# For core flock types, import directly
-from flock.core.context.context import FlockContext
-from flock.core.context.context_vars import FLOCK_MODEL
-from flock.core.flock_agent import FlockAgent  # Import concrete class if needed
-from flock.core.registry import get_registry
-# HandOffRequest removed - using agent.next_agent directly
-from flock.core.logging.logging import get_logger
-from flock.core.util.input_resolver import resolve_inputs
-
-logger = get_logger("agent_activity")  # Using a distinct logger category
-tracer = trace.get_tracer(__name__)
-registry = get_registry()  # Get registry instance once
-
-
-@activity.defn
-async def execute_single_agent(agent_name: str, context_dict: dict) -> dict:
-    """Executes a single specified agent and returns its result.
-
-    Args:
-        agent_name: The name of the agent to execute.
-        context: The current FlockContext (passed from the workflow).
-
-    Returns:
-        The raw result dictionary from the agent's execution.
-
-    Raises:
-        ValueError: If the agent is not found in the registry.
-        Exception: Propagates exceptions from agent execution for Temporal retries.
-    """
-    with tracer.start_as_current_span("execute_single_agent") as span:
-        span.set_attribute("agent.name", agent_name)
-        logger.info("Executing single agent", agent=agent_name)
-
-        agent = registry.get_agent(agent_name)
-        if not agent:
-            logger.error("Agent not found in registry", agent=agent_name)
-            # Raise error for Temporal to potentially retry/fail the activity
-            raise ValueError(f"Agent '{agent_name}' not found in registry.")
-
-        # Rehydrate context from dict and set on agent (transient for this execution)
-        context = FlockContext.from_dict(context_dict)
-        agent.context = context
-
-        # Ensure model is set (using context value if needed)
-        # Consider if this should be done once when agent is added or workflow starts
-        if agent.model is None:
-            agent_model = context.get_variable(FLOCK_MODEL)
-            if agent_model:
-                agent.set_model(agent_model)
-                logger.debug(
-                    f"Set model for agent '{agent_name}' from context: {agent_model}"
-                )
-
-        # Resolve agent-specific callables if necessary
-        # This might be better handled in the workflow before the loop starts
-        # or when agents are initially loaded. Assuming it's handled elsewhere for now.
-        # agent.resolve_callables(context=context)
-
-        # Resolve inputs for this specific agent run
-        previous_agent_name = context.get_last_agent_name()  # May be None on first agent
-        prev_def = (
-            context.get_agent_definition(previous_agent_name)
-            if previous_agent_name
-            else None
-        )
-        prev_out_spec = (
-            (prev_def.agent_data.get("output_spec") if isinstance(prev_def, type(prev_def)) else None)
-            if prev_def and isinstance(prev_def.agent_data, dict)
-            else None
-        )
-        prev_cfg = (
-            prev_def.agent_data.get("config")
-            if prev_def and isinstance(prev_def.agent_data, dict)
-            else {}
-        )
-        prev_strategy = (
-            prev_cfg.get("handoff_strategy") if isinstance(prev_cfg, dict) else None
-        ) or "static"
-        prev_map = (
-            prev_cfg.get("handoff_map") if isinstance(prev_cfg, dict) else None
-        ) or {}
-        logger.debug(
-            f"Resolving inputs for {agent_name} with previous agent {previous_agent_name}"
-        )
-        agent_inputs = resolve_inputs(
-            agent.input,
-            context,
-            previous_agent_name or "",
-            prev_out_spec or "",
-            prev_strategy,
-            prev_map,
-        )
-        span.add_event(
-            "resolved inputs", attributes={"inputs": str(agent_inputs)}
-        )
-
-        try:
-            # Execute just this agent
-            result = await agent.run_async(agent_inputs)
-            # Avoid logging potentially large results directly to span attributes
-            result_str = str(result)
-            span.set_attribute("result.type", type(result).__name__)
-            span.set_attribute(
-                "result.preview",
-                result_str[:500] + ("..." if len(result_str) > 500 else ""),
-            )
-            logger.info("Single agent execution completed", agent=agent_name)
-            return result
-        except Exception as e:
-            logger.error(
-                "Single agent execution failed",
-                agent=agent_name,
-                error=str(e),
-                exc_info=True,
-            )
-            # Debug aid: ensure exception prints even if logger is muted in environment
-            print(f"[agent_activity] Single agent execution failed for {agent_name}: {e!r}")
-            span.record_exception(e)
-            # Re-raise the exception for Temporal to handle based on retry policy
-            raise
-
-
-@activity.defn
-async def determine_next_agent(
-    current_agent_name: str, result: dict, context_dict: dict
-) -> str | None:
-    """Determine the next agent using the agent's routing component.
-
-    Returns the next agent's name or None if the workflow should terminate.
-    """
-    with tracer.start_as_current_span("determine_next_agent") as span:
-        span.set_attribute("agent.name", current_agent_name)
-        logger.info("Determining next agent after", agent=current_agent_name)
-
-        agent = registry.get_agent(current_agent_name)
-        if not agent:
-            logger.error(
-                "Agent not found for routing", agent=current_agent_name
-            )
-            raise ValueError(
-                f"Agent '{current_agent_name}' not found for routing."
-            )
-
-        if not agent.router:
-            logger.info(
-                "No router defined for agent", agent=current_agent_name
-            )
-            span.add_event("no_router")
-            return None  # Indicate no handoff
-
-        logger.debug(
-            f"Using router {agent.router.__class__.__name__}",
-            agent=agent.name,
-        )
-        try:
-            # Execute routing logic on the router component (unified architecture)
-            context = FlockContext.from_dict(context_dict)
-            next_val = await agent.router.determine_next_step(agent, result, context)
-
-            # Convert to a simple agent name if needed
-            if isinstance(next_val, FlockAgent):
-                next_name = next_val.name
-            elif isinstance(next_val, str):
-                next_name = next_val
-            else:
-                next_name = None
-
-            if not next_name:
-                logger.info("Router determined no next agent", agent=agent.name)
-                span.add_event("no_next_agent_from_router")
-                return None
-
-            logger.info(
-                "Next agent determined",
-                next_agent=next_name,
-                agent=agent.name,
-            )
-            span.set_attribute("next_agent", next_name)
-            return next_name
-
-        except Exception as e:
-            # Catch potential errors during routing execution
-            logger.error(
-                "Router execution failed",
-                agent=agent.name,
-                error=str(e),
-                exc_info=True,
-            )
-            print(f"[agent_activity] Router execution failed for {agent.name}: {e!r}")
-            span.record_exception(e)
-            # Let Temporal handle the activity failure based on retry policy
-            raise

flock/workflow/flock_workflow.py

@@ -1,214 +0,0 @@
-from datetime import timedelta
-from typing import Any
-
-from temporalio import workflow
-
-# Import activities from the new file
-with workflow.unsafe.imports_passed_through():
-    from flock.core.context.context import AgentDefinition, FlockContext
-    from flock.core.context.context_vars import FLOCK_CURRENT_AGENT
-    # HandOffRequest removed - using agent.next_agent directly
-    from flock.core.logging.logging import get_logger
-    from flock.workflow.agent_execution_activity import (
-        determine_next_agent,
-        execute_single_agent,
-    )
-    from flock.workflow.temporal_config import (
-        TemporalActivityConfig,
-        TemporalRetryPolicyConfig,
-    )
-
-
-logger = get_logger("workflow")
-
-
-@workflow.defn
-class FlockWorkflow:
-    # No need for __init__ storing context anymore if passed to run
-
-    @workflow.run
-    async def run(self, workflow_args: dict[str, Any]) -> dict:
-        # --- Workflow Initialization ---
-        # Arguments are packed into a single dictionary
-        context_dict = workflow_args["context_dict"]
-        default_retry_config_dict = workflow_args["default_retry_config_dict"]
-
-        # Deserialize context and default retry config
-        context = FlockContext.from_dict(context_dict)
-        default_retry_config = TemporalRetryPolicyConfig.model_validate(
-            default_retry_config_dict
-        )
-
-        context.workflow_id = workflow.info().workflow_id
-        context.workflow_timestamp = workflow.info().start_time.strftime(
-            "%Y-%m-%d %H:%M:%S"
-        )
-
-        current_agent_name = context.get_variable(FLOCK_CURRENT_AGENT)
-        final_result = None
-        previous_agent_name = (
-            None  # Keep track of the agent that called the current one
-        )
-
-        logger.info(
-            "Starting workflow execution",
-            workflow_id=context.workflow_id,
-            start_time=context.workflow_timestamp,
-            initial_agent=current_agent_name,
-        )
-
-        try:
-            while current_agent_name:
-                logger.info(
-                    "Executing agent activity", agent=current_agent_name
-                )
-
-                # --- Determine Activity Settings ---
-                agent_def: AgentDefinition | None = (
-                    context.get_agent_definition(current_agent_name)
-                )
-                agent_activity_config: TemporalActivityConfig | None = None
-                final_retry_config = (
-                    default_retry_config  # Start with the workflow default
-                )
-
-                if agent_def and agent_def.agent_data.get(
-                    "temporal_activity_config"
-                ):
-                    try:
-                        agent_activity_config = (
-                            TemporalActivityConfig.model_validate(
-                                agent_def.agent_data["temporal_activity_config"]
-                            )
-                        )
-                        logger.debug(
-                            f"Loaded agent-specific temporal config for {current_agent_name}"
-                        )
-                    except Exception as e:
-                        logger.warn(
-                            f"Failed to validate agent temporal config for {current_agent_name}: {e}. Using defaults."
-                        )
-
-                # Layering logic: Agent config overrides workflow default config
-                activity_task_queue = (
-                    workflow.info().task_queue
-                )  # Default to workflow task queue
-                activity_timeout = timedelta(
-                    minutes=5
-                )  # Fallback default timeout
-
-                if agent_activity_config:
-                    activity_task_queue = (
-                        agent_activity_config.task_queue or activity_task_queue
-                    )
-                    activity_timeout = (
-                        agent_activity_config.start_to_close_timeout
-                        or activity_timeout
-                    )
-                    if agent_activity_config.retry_policy:
-                        final_retry_config = agent_activity_config.retry_policy
-
-                # Convert config to actual Temporal object
-                final_retry_policy = final_retry_config.to_temporalio_policy()
-
-                logger.debug(
-                    f"Final activity settings for {current_agent_name}: "
-                    f"queue='{activity_task_queue}', timeout={activity_timeout}, "
-                    f"retries={final_retry_policy.maximum_attempts}"
-                )
-
-                # --- Execute the current agent activity ---
-                try:
-                    agent_result = await workflow.execute_activity(
-                        execute_single_agent,
-                        args=[current_agent_name, context.model_dump(mode="json")],
-                        task_queue=activity_task_queue,
-                        start_to_close_timeout=activity_timeout,
-                        retry_policy=final_retry_policy,
-                    )
-                except Exception as e:
-                    logger.error("execute_single_agent activity failed", agent=current_agent_name, error=str(e))
-                    raise
-
-                # Record the execution in the context history
-                # Note: The 'called_from' is the agent *before* this one
-                context.record(
-                    agent_name=current_agent_name,
-                    data=agent_result,
-                    timestamp=workflow.now().isoformat(),  # Use deterministic workflow time
-                    hand_off=None,  # Will be updated if handoff occurs
-                    called_from=previous_agent_name,  # Pass the correct previous agent
-                )
-
-                final_result = agent_result  # Store the result of the last successful agent
-
-                logger.info(
-                    "Determining next agent activity",
-                    current_agent=current_agent_name,
-                )
-                # --- Determine the next agent (using routing component) ---
-                try:
-                    next_agent_name = await workflow.execute_activity(
-                        determine_next_agent,
-                        args=[current_agent_name, agent_result, context.model_dump(mode="json")],
-                        start_to_close_timeout=timedelta(minutes=1),
-                        retry_policy=default_retry_config.to_temporalio_policy(),
-                    )
-                except Exception as e:
-                    logger.error("determine_next_agent activity failed", agent=current_agent_name, error=str(e))
-                    raise
-
-                # Update previous agent name for the next loop iteration
-                previous_agent_name = current_agent_name
-
-                if next_agent_name:
-                    logger.debug("Next agent received", data=next_agent_name)
-                    # Update the last record's handoff information for observability
-                    if context.history:
-                        context.history[-1].hand_off = {"next_agent": next_agent_name}
-
-                    # Set the next agent
-                    current_agent_name = next_agent_name
-                    context.set_variable(FLOCK_CURRENT_AGENT, current_agent_name)
-                    logger.info("Next agent set", agent=current_agent_name)
-                else:
-                    logger.info("No next agent, workflow terminating.")
-                    current_agent_name = None
-
-            # --- Workflow Completion ---
-            logger.success(
-                "Workflow completed successfully",
-                final_agent=previous_agent_name,
-            )
-            context.set_variable(
-                "flock.result",
-                {
-                    "result": final_result,  # Return the last agent's result
-                    "success": True,
-                },
-            )
-            return final_result  # Return the actual result of the last agent
-
-        except Exception as e:
-            # Catch exceptions from activities (e.g., after retries fail) or workflow logic errors
-            logger.exception(f"Workflow execution failed: {e!r}")
-            try:
-                from temporalio.exceptions import ActivityError
-                if isinstance(e, ActivityError) and getattr(e, "cause", None) is not None:
-                    logger.error(f"ActivityError cause: {e.cause!r}")
-            except Exception:
-                pass
-            context.set_variable(
-                "flock.result",
-                {
-                    "result": f"Workflow failed: {e}",
-                    "success": False,
-                },
-            )
-            # It's often better to let Temporal record the failure status
-            # by re-raising the exception rather than returning a custom error dict.
-            # However, returning the context might be useful for debugging.
-            # Consider re-raising: raise
-            return context.model_dump(
-                mode="json"
-            )  # Return context state on failure