flock-core 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

flock/themes/zenbones.toml

@@ -0,0 +1,77 @@
+[rich]
+panel_style = "on #f0edec"
+table_header_style = "bold #2c363c on #cbd9e3"
+table_title_style = "bold #2c363c"
+table_border_style = "#1d5573"
+panel_border_style = "#1d5573"
+column_output = "bold #2c363c"
+column_value = "#2c363c"
+bright_black = "#cfc1ba"
+bright_blue = "#1d5573"
+bright_cyan = "#2b747c"
+bright_green = "#3f5a22"
+bright_magenta = "#7b3b70"
+bright_red = "#94253e"
+bright_white = "#4f5e68"
+bright_yellow = "#803d1c"
+normal_black = "#f0edec"
+normal_blue = "#286486"
+normal_cyan = "#3b8992"
+normal_green = "#4f6c31"
+normal_magenta = "#88507d"
+normal_red = "#a8334c"
+normal_white = "#2c363c"
+normal_yellow = "#944927"
+cursor_cursor = "#2c363c"
+cursor_text = "#f0edec"
+table_show_lines = true
+table_box = "MINIMAL"
+panel_padding = [ 1, 2,]
+panel_title_align = "left"
+table_row_styles = [ "", "italic",]
+table_safe_box = true
+table_padding = [ 0, 1,]
+table_collapse_padding = false
+table_pad_edge = true
+table_expand = false
+table_show_footer = false
+table_show_edge = true
+table_leading = 0
+table_style = "none"
+table_footer_style = "none"
+table_caption_style = "none"
+table_title_justify = "center"
+table_caption_justify = "center"
+table_highlight = false
+
+[colors.bright]
+black = "#cfc1ba"
+blue = "#1d5573"
+cyan = "#2b747c"
+green = "#3f5a22"
+magenta = "#7b3b70"
+red = "#94253e"
+white = "#4f5e68"
+yellow = "#803d1c"
+
+[colors.cursor]
+cursor = "#2c363c"
+text = "#f0edec"
+
+[colors.normal]
+black = "#f0edec"
+blue = "#286486"
+cyan = "#3b8992"
+green = "#4f6c31"
+magenta = "#88507d"
+red = "#a8334c"
+white = "#2c363c"
+yellow = "#944927"
+
+[colors.primary]
+background = "#f0edec"
+foreground = "#2c363c"
+
+[colors.selection]
+background = "#cbd9e3"
+text = "#2c363c"

flock/themes/zenburn.toml

@@ -0,0 +1,77 @@
+[rich]
+panel_style = "on #3f3f3f"
+table_header_style = "bold #c2d87a on #21322f"
+table_title_style = "bold #dcdccc"
+table_border_style = "#94bff3"
+panel_border_style = "#94bff3"
+column_output = "bold #dcdccc"
+column_value = "#dcdccc"
+bright_black = "#709080"
+bright_blue = "#94bff3"
+bright_cyan = "#93e0e3"
+bright_green = "#c3bf9f"
+bright_magenta = "#ec93d3"
+bright_red = "#dca3a3"
+bright_white = "#ffffff"
+bright_yellow = "#e0cf9f"
+normal_black = "#4d4d4d"
+normal_blue = "#506070"
+normal_cyan = "#8cd0d3"
+normal_green = "#60b48a"
+normal_magenta = "#dc8cc3"
+normal_red = "#705050"
+normal_white = "#dcdccc"
+normal_yellow = "#f0dfaf"
+cursor_cursor = "#73635a"
+cursor_text = "#000000"
+table_show_lines = false
+table_box = "HEAVY"
+panel_padding = [ 1, 2,]
+panel_title_align = "center"
+table_row_styles = [ "", "italic",]
+table_safe_box = true
+table_padding = [ 0, 1,]
+table_collapse_padding = false
+table_pad_edge = true
+table_expand = false
+table_show_footer = false
+table_show_edge = true
+table_leading = 0
+table_style = "none"
+table_footer_style = "none"
+table_caption_style = "none"
+table_title_justify = "center"
+table_caption_justify = "center"
+table_highlight = false
+
+[colors.bright]
+black = "#709080"
+blue = "#94bff3"
+cyan = "#93e0e3"
+green = "#c3bf9f"
+magenta = "#ec93d3"
+red = "#dca3a3"
+white = "#ffffff"
+yellow = "#e0cf9f"
+
+[colors.cursor]
+cursor = "#73635a"
+text = "#000000"
+
+[colors.normal]
+black = "#4d4d4d"
+blue = "#506070"
+cyan = "#8cd0d3"
+green = "#60b48a"
+magenta = "#dc8cc3"
+red = "#705050"
+white = "#dcdccc"
+yellow = "#f0dfaf"
+
+[colors.primary]
+background = "#3f3f3f"
+foreground = "#dcdccc"
+
+[colors.selection]
+background = "#21322f"
+text = "#c2d87a"

flock/themes/zenburned.toml

@@ -0,0 +1,77 @@
+[rich]
+panel_style = "on #404040"
+table_header_style = "bold #f0e4cf on #746956"
+table_title_style = "bold #f0e4cf"
+table_border_style = "#61abda"
+panel_border_style = "#61abda"
+column_output = "bold #f0e4cf"
+column_value = "#f0e4cf"
+bright_black = "#625a5b"
+bright_blue = "#61abda"
+bright_cyan = "#65b8c1"
+bright_green = "#8bae68"
+bright_magenta = "#cf86c1"
+bright_red = "#ec8685"
+bright_white = "#c0ab86"
+bright_yellow = "#d68c67"
+normal_black = "#404040"
+normal_blue = "#6099c0"
+normal_cyan = "#66a5ad"
+normal_green = "#819b69"
+normal_magenta = "#b279a7"
+normal_red = "#e3716e"
+normal_white = "#f0e4cf"
+normal_yellow = "#b77e64"
+cursor_cursor = "#f3eadb"
+cursor_text = "#404040"
+table_show_lines = true
+table_box = "HEAVY"
+panel_padding = [ 1, 2,]
+panel_title_align = "center"
+table_row_styles = [ "", "dim",]
+table_safe_box = true
+table_padding = [ 0, 1,]
+table_collapse_padding = false
+table_pad_edge = true
+table_expand = false
+table_show_footer = false
+table_show_edge = true
+table_leading = 0
+table_style = "none"
+table_footer_style = "none"
+table_caption_style = "none"
+table_title_justify = "center"
+table_caption_justify = "center"
+table_highlight = false
+
+[colors.bright]
+black = "#625a5b"
+blue = "#61abda"
+cyan = "#65b8c1"
+green = "#8bae68"
+magenta = "#cf86c1"
+red = "#ec8685"
+white = "#c0ab86"
+yellow = "#d68c67"
+
+[colors.cursor]
+cursor = "#f3eadb"
+text = "#404040"
+
+[colors.normal]
+black = "#404040"
+blue = "#6099c0"
+cyan = "#66a5ad"
+green = "#819b69"
+magenta = "#b279a7"
+red = "#e3716e"
+white = "#f0e4cf"
+yellow = "#b77e64"
+
+[colors.primary]
+background = "#404040"
+foreground = "#f0e4cf"
+
+[colors.selection]
+background = "#746956"
+text = "#f0e4cf"

flock/themes/zenwritten-dark.toml

@@ -0,0 +1,77 @@
+[rich]
+panel_style = "on #191919"
+table_header_style = "bold #bbbbbb on #404040"
+table_title_style = "bold #bbbbbb"
+table_border_style = "#61abda"
+panel_border_style = "#61abda"
+column_output = "bold #bbbbbb"
+column_value = "#bbbbbb"
+bright_black = "#3d3839"
+bright_blue = "#61abda"
+bright_cyan = "#65b8c1"
+bright_green = "#8bae68"
+bright_magenta = "#cf86c1"
+bright_red = "#e8838f"
+bright_white = "#8e8e8e"
+bright_yellow = "#d68c67"
+normal_black = "#191919"
+normal_blue = "#6099c0"
+normal_cyan = "#66a5ad"
+normal_green = "#819b69"
+normal_magenta = "#b279a7"
+normal_red = "#de6e7c"
+normal_white = "#bbbbbb"
+normal_yellow = "#b77e64"
+cursor_cursor = "#c9c9c9"
+cursor_text = "#191919"
+table_show_lines = true
+table_box = "HEAVY"
+panel_padding = [ 1, 2,]
+panel_title_align = "right"
+table_row_styles = [ "", "underline",]
+table_safe_box = true
+table_padding = [ 0, 1,]
+table_collapse_padding = false
+table_pad_edge = true
+table_expand = false
+table_show_footer = false
+table_show_edge = true
+table_leading = 0
+table_style = "none"
+table_footer_style = "none"
+table_caption_style = "none"
+table_title_justify = "center"
+table_caption_justify = "center"
+table_highlight = false
+
+[colors.bright]
+black = "#3d3839"
+blue = "#61abda"
+cyan = "#65b8c1"
+green = "#8bae68"
+magenta = "#cf86c1"
+red = "#e8838f"
+white = "#8e8e8e"
+yellow = "#d68c67"
+
+[colors.cursor]
+cursor = "#c9c9c9"
+text = "#191919"
+
+[colors.normal]
+black = "#191919"
+blue = "#6099c0"
+cyan = "#66a5ad"
+green = "#819b69"
+magenta = "#b279a7"
+red = "#de6e7c"
+white = "#bbbbbb"
+yellow = "#b77e64"
+
+[colors.primary]
+background = "#191919"
+foreground = "#bbbbbb"
+
+[colors.selection]
+background = "#404040"
+text = "#bbbbbb"

flock/themes/zenwritten-light.toml

@@ -0,0 +1,77 @@
+[rich]
+panel_style = "on #eeeeee"
+table_header_style = "bold #353535 on #d7d7d7"
+table_title_style = "bold #353535"
+table_border_style = "#1d5573"
+panel_border_style = "#1d5573"
+column_output = "bold #353535"
+column_value = "#353535"
+bright_black = "#c6c3c3"
+bright_blue = "#1d5573"
+bright_cyan = "#2b747c"
+bright_green = "#3f5a22"
+bright_magenta = "#7b3b70"
+bright_red = "#94253e"
+bright_white = "#5c5c5c"
+bright_yellow = "#803d1c"
+normal_black = "#eeeeee"
+normal_blue = "#286486"
+normal_cyan = "#3b8992"
+normal_green = "#4f6c31"
+normal_magenta = "#88507d"
+normal_red = "#a8334c"
+normal_white = "#353535"
+normal_yellow = "#944927"
+cursor_cursor = "#353535"
+cursor_text = "#eeeeee"
+table_show_lines = false
+table_box = "SQUARE"
+panel_padding = [ 1, 2,]
+panel_title_align = "center"
+table_row_styles = [ "", "dim",]
+table_safe_box = true
+table_padding = [ 0, 1,]
+table_collapse_padding = false
+table_pad_edge = true
+table_expand = false
+table_show_footer = false
+table_show_edge = true
+table_leading = 0
+table_style = "none"
+table_footer_style = "none"
+table_caption_style = "none"
+table_title_justify = "center"
+table_caption_justify = "center"
+table_highlight = false
+
+[colors.bright]
+black = "#c6c3c3"
+blue = "#1d5573"
+cyan = "#2b747c"
+green = "#3f5a22"
+magenta = "#7b3b70"
+red = "#94253e"
+white = "#5c5c5c"
+yellow = "#803d1c"
+
+[colors.cursor]
+cursor = "#353535"
+text = "#eeeeee"
+
+[colors.normal]
+black = "#eeeeee"
+blue = "#286486"
+cyan = "#3b8992"
+green = "#4f6c31"
+magenta = "#88507d"
+red = "#a8334c"
+white = "#353535"
+yellow = "#944927"
+
+[colors.primary]
+background = "#eeeeee"
+foreground = "#353535"
+
+[colors.selection]
+background = "#d7d7d7"
+text = "#353535"

flock/workflow/activities.py

@@ -1,115 +1,117 @@
-"""Defines Temporal activities for running a chain of agents."""
-
-from datetime import datetime
-
-from temporalio import activity
-
-from flock.core.agent import Agent
-from flock.core.agent_registry import Registry
-from flock.core.context import FlockContext
-from flock.core.context_vars import FLOCK_CURRENT_AGENT, FLOCK_INITIAL_INPUT
-from flock.core.handoff.handoff_base import HandoffBase
-from flock.core.logging import flock_logger
-
-
-@activity.defn
-async def run_agent(context: FlockContext) -> dict:
-    """Runs a chain of agents using the provided context.
-
-    The context contains:
-      - A state (e.g., "init_input", "current_agent", etc.),
-      - A history of agent runs.
-
-    Each agent uses the current value of the variable specified in its `input` attribute.
-    After each run, its output is merged into the context state.
-    The default handoff behavior is to fetch the next agent's input automatically from the context.
-    """
-    registry = Registry()
-    current_agent_name = context.get_variable(FLOCK_CURRENT_AGENT)
-    flock_logger.info(f"Starting agent chain with initial agent", agent=current_agent_name)
-
-    agent = registry.get_agent(current_agent_name)
-    if not agent:
-        flock_logger.error(f"Agent not found", agent=current_agent_name)
-        return {"error": f"Agent '{current_agent_name}' not found."}
-
-    while agent:
-        # Determine the input for this agent.
-        # (Preferably, the agent's input key is used; otherwise "init_input" is assumed.)
-        agent_input = (
-            context.get_variable(agent.input)
-            if getattr(agent, "input", None)
-            else context.get_variable(FLOCK_INITIAL_INPUT)
-        )
-        flock_logger.info(
-            "Determined agent input", agent=agent.name, input_source=getattr(agent, "input", "FLOCK_INITIAL_INPUT")
-        )
-
-        # Prepare a deep copy of the state for the agent's run.
-        local_context = FlockContext.from_dict(context.to_dict())
-        local_context.set_variable(
-            f"{agent.name}.{agent.input}", agent_input
-        )  # ensure the agent's expected input is set
-
-        # Execute the agent.
-        flock_logger.info("Executing agent", agent=agent.name)
-        result = await agent.run(local_context)
-        flock_logger.info("Agent execution completed", agent=agent.name)
-
-        # If no handoff is defined, return the result.
-        if not agent.hand_off:
-            # Record the agent's execution.
-            context.record(agent.name, result, timestamp=datetime.now(), hand_off=None)
-            flock_logger.info("No handoff defined, completing chain", agent=agent.name)
-            return result
-
-        # Determine the next agent.
-        if callable(agent.hand_off):
-            # The handoff function may override the default behavior:
-            # it can explicitly return a dict with "next_agent" and optionally "input"
-            flock_logger.info("Executing handoff function", agent=agent.name)
-            handoff_data: HandoffBase = agent.hand_off(context, result)
-            if isinstance(handoff_data.next_agent, Agent):
-                next_agent_name = handoff_data.next_agent.name
-            else:
-                next_agent_name = handoff_data.next_agent
-
-            # Use the provided new input if present, otherwise let the context update be automatic.
-            if handoff_data.input:
-                context.state["init_input"] = handoff_data["input"]
-                flock_logger.debug("Using handoff-provided input", agent=agent.name)
-            if handoff_data.context_params:
-                context.state.update(handoff_data.context_params)
-                flock_logger.debug("Updated context with handoff params", agent=agent.name)
-        elif isinstance(agent.hand_off, str | Agent):
-            next_agent_name = agent.hand_off if isinstance(agent.hand_off, str) else agent.hand_off.name
-
-        else:
-            return {"error": "Unsupported hand_off type."}
-        context.record(agent.name, result, timestamp=datetime.now(), hand_off=next_agent_name)
-        # Update the current agent and prepare the next input automatically.
-        next_agent = registry.get_agent(next_agent_name)
-        if not next_agent:
-            flock_logger.error("Next agent not found", agent=next_agent_name)
-            return {"error": f"Next agent '{next_agent_name}' not found."}
-
-        context.state["current_agent"] = next_agent.name
-        # By default, the next input is determined from the current state using next_input_for().
-        context.state["init_input"] = context.next_input_for(next_agent)
-        flock_logger.info("Handing off to next agent", current=agent.name, next=next_agent.name)
-        agent = next_agent
-
-    # If the loop ever terminates without a final result, return the latest state value.
-    flock_logger.info("Chain completed, returning final state")
-    return context.get_variable("init_input")
-
-
-@activity.defn
-async def get_next_agent(name: str) -> Agent | None:
-    """Retrieves the agent with the given name from the registry."""
-    flock_logger.debug("Looking up next agent", agent=name)
-    registry = Registry()
-    agent = registry.get_agent(name)
-    if not agent:
-        flock_logger.warning("Next agent not found", agent=name)
-    return agent
+"""Defines Temporal activities for running a chain of agents."""
+
+from datetime import datetime
+
+from temporalio import activity
+
+from flock.core.context.context import FlockContext
+from flock.core.context.context_vars import FLOCK_CURRENT_AGENT
+from flock.core.flock_agent import FlockAgent, HandoffBase
+from flock.core.logging.formatters.base_formatter import FormatterOptions
+from flock.core.logging.formatters.formatter_factory import FormatterFactory
+from flock.core.logging.logging import get_logger
+from flock.core.registry.agent_registry import Registry
+from flock.core.util.input_resolver import resolve_inputs
+
+logger = get_logger("activities")
+
+
+@activity.defn
+async def run_agent(
+    context: FlockContext, output_formatter: FormatterOptions = None
+) -> dict:
+    """Runs a chain of agents using the provided context.
+
+    The context contains:
+      - A state (e.g., "init_input", "current_agent", etc.),
+      - A history of agent runs.
+
+    Each agent uses the current value of the variable specified in its `input` attribute.
+    After each run, its output is merged into the context state.
+    The default handoff behavior is to fetch the next agent's input automatically from the context.
+    """
+    registry = Registry()
+    previous_agent_name = ""
+    current_agent_name = context.get_variable(FLOCK_CURRENT_AGENT)
+    handoff_data: HandoffBase = None
+
+    logger.info("Starting agent chain", initial_agent=current_agent_name)
+
+    agent = registry.get_agent(current_agent_name)
+    if not agent:
+        logger.error("Agent not found", agent=current_agent_name)
+        return {"error": f"Agent '{current_agent_name}' not found."}
+
+    while agent:
+        # Get the inputs for the agent
+
+        agent_inputs = resolve_inputs(agent.input, context, previous_agent_name)
+
+        # Execute the agent
+        logger.info("Executing agent")
+        result = await agent.run(agent_inputs)
+        logger.debug("Agent execution completed")
+
+        if output_formatter:
+            formatter = FormatterFactory.create_formatter(output_formatter)
+            formatter.display(
+                result, agent.name, output_formatter.wait_for_input
+            )
+
+        # If no handoff is defined, return the result
+        if not agent.hand_off:
+            context.record(
+                agent.name,
+                result,
+                timestamp=datetime.now(),
+                hand_off=None,
+                called_from=previous_agent_name,
+            )
+            logger.info("No handoff defined, completing chain")
+            return result
+
+        # Determine the next agent
+        handoff_data = HandoffBase()
+        if callable(agent.hand_off):
+            logger.debug("Executing handoff function")
+            handoff_data = agent.hand_off(context, result)
+            if isinstance(handoff_data.next_agent, FlockAgent):
+                handoff_data.next_agent = handoff_data.next_agent.name
+
+        elif isinstance(agent.hand_off, str | FlockAgent):
+            handoff_data.next_agent = (
+                agent.hand_off
+                if isinstance(agent.hand_off, str)
+                else agent.hand_off.name
+            )
+        else:
+            logger.error("Unsupported hand_off type")
+            return {"error": "Unsupported hand_off type."}
+
+        context.record(
+            agent.name,
+            result,
+            timestamp=datetime.now().isoformat(),
+            hand_off=handoff_data,
+            called_from=previous_agent_name,
+        )
+        previous_agent_name = agent.name
+
+        # Update the current agent and prepare the next input automatically
+        try:
+            agent = registry.get_agent(handoff_data.next_agent)
+            if not agent:
+                logger.error(
+                    "Next agent not found", agent=handoff_data.next_agent
+                )
+                return {
+                    "error": f"Next agent '{handoff_data.next_agent}' not found."
+                }
+
+            context.set_variable(FLOCK_CURRENT_AGENT, agent.name)
+            logger.info("Handing off to next agent", next=agent.name)
+        except Exception as e:
+            logger.error("Error during handoff", error=e)
+            return {"error": f"Error during handoff: {e}"}
+
+    return context.get_variable("init_input")

flock/workflow/agent_activities.py

@@ -1,26 +1,24 @@
-from temporalio import activity
-
-from flock.agents.declarative_agent import DeclarativeAgent
-from flock.core.context import FlockContext
-
-
-@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 = DeclarativeAgent.parse_obj(agent_data)
-    # Reconstruct the FlockContext from the state.
-    state = context_data.get("state", {})
-    # (For simplicity, we ignore history and agent_definitions here. You can extend this if needed.)
-    context = FlockContext(state=state)
-    result = await agent._evaluate(context)
-    return result
+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