zero-agent 0.1.0__py3-none-any.whl

pipelines/data_scientist.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from agentz.agent.base import ContextAgent
+from agentz.context.context import Context
+from pipelines.base import BasePipeline
+
+
+class DataScienceQuery(BaseModel):
+    """Query model for data science tasks."""
+    prompt: str
+    data_path: str
+
+    def format(self) -> str:
+        """Format data science query."""
+        return (
+            f"Task: {self.prompt}\n"
+            f"Dataset path: {self.data_path}\n"
+            "Provide a comprehensive data science workflow"
+        )
+
+
+class DataScientistPipeline(BasePipeline):
+    """Data science pipeline using manager-tool pattern.
+
+    This pipeline demonstrates the minimal implementation needed:
+    - __init__: Setup agents
+    - execute: Implement the workflow logic
+    - DataScienceQuery.format(): Format query (handled automatically by BasePipeline)
+
+    All other logic (iteration, tool execution, memory save) is handled by BasePipeline.
+    """
+
+    def __init__(self, config):
+        """Initialize pipeline with explicit manager agents and tool agent dictionary."""
+        super().__init__(config)
+
+        # Initialize context and profiles
+        self.context = Context(["profiles", "states"])
+        llm = self.config.llm.main_model
+
+        # Create manager agents - automatically bound to pipeline with role
+        self.observe_agent = ContextAgent.from_profile(self, "observe", llm)
+        self.evaluate_agent = ContextAgent.from_profile(self, "evaluate", llm)
+        self.routing_agent = ContextAgent.from_profile(self, "routing", llm)
+        self.writer_agent = ContextAgent.from_profile(self, "writer", llm)
+
+        # Create tool agents as dictionary - automatically bound to pipeline
+        tool_names = [
+            "data_loader",
+            "data_analysis",
+            "preprocessing",
+            "model_training",
+            "evaluation",
+            "visualization",
+        ]
+        self.tool_agents = {
+            f"{name}_agent": ContextAgent.from_profile(self, name, llm)
+            for name in tool_names
+        }
+
+    async def execute(self) -> Any:
+        """Execute data science workflow - full implementation in one function."""
+        self.update_printer("research", "Executing research workflow...")
+
+        # Iterative loop: observe → evaluate → route → tools
+        while self.iteration < self.max_iterations and not self.context.state.complete:
+            # Begin iteration with its group
+            _, group_id = self.begin_iteration()
+
+            query = self.context.state.query
+
+            # Observe → Evaluate → Route → Tools
+            observe_output = await self.observe_agent(query, group_id=group_id)
+            evaluate_output = await self.evaluate_agent(observe_output, group_id=group_id)
+
+            if not self.context.state.complete:
+                routing_output = await self.routing_agent(self._serialize_output(evaluate_output), group_id=group_id)
+                await self._execute_tools(routing_output, self.tool_agents, group_id)
+
+            # End iteration with its group
+            self.end_iteration(group_id)
+
+            if self.context.state.complete:
+                break
+
+        # Final report
+        final_group = self.begin_final_report()
+        self.update_printer("research", "Research workflow complete", is_done=True)
+
+        findings = self.context.state.findings_text()
+        await self.writer_agent(findings, group_id=final_group)
+
+        self.end_final_report(final_group)

pipelines/data_scientist_memory.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from agentz.agent.base import ContextAgent
+from agentz.context.conversation import create_conversation_state
+from agentz.context.context import Context
+from agentz.profiles.manager.memory import MemoryAgentOutput
+from agentz.profiles.manager.evaluate import EvaluateOutput
+from agentz.profiles.manager.routing import AgentSelectionPlan
+from agentz.profiles.base import load_all_profiles
+from pipelines.data_scientist import DataScientistPipeline
+
+
+class DataScientistMemoryPipeline(DataScientistPipeline):
+    """Data scientist pipeline variant that maintains iterative memory compression."""
+
+    def __init__(self, config):
+        # Don't call super().__init__ yet - we need to customize
+        # Call BasePipeline.__init__ directly
+        from pipelines.base import BasePipeline
+        BasePipeline.__init__(self, config)
+
+        profiles = load_all_profiles()
+        state = create_conversation_state(profiles=profiles)
+        llm = self.config.llm.main_model
+
+        # Centralized context engine with state and behaviors (including memory)
+        self.context = Context(
+            state=state,
+            behaviors=["observe", "evaluate", "route", "writer", "memory"],
+            config=config,
+        )
+
+        # Manager agents with memory support
+        self.observe_agent = ContextAgent.from_profile(profiles["observe"], llm)
+        self.evaluate_agent = ContextAgent.from_profile(profiles["evaluate"], llm)
+        self.routing_agent = ContextAgent.from_profile(profiles["routing"], llm)
+        self.writer_agent = ContextAgent.from_profile(profiles["writer"], llm)
+        self.memory_agent = ContextAgent.from_profile(profiles["memory"], llm)
+
+        # Tool agents for specialized tasks
+        self.tool_agents: Dict[str, Any] = {
+            f"{name}_agent": ContextAgent.from_profile(profiles[name], llm)
+            for name in ["data_loader", "data_analysis", "preprocessing",
+                        "model_training", "evaluation", "visualization"]
+        }
+
+        # Optional report configuration
+        self.report_length: Optional[str] = None
+        self.report_instructions: Optional[str] = None
+
+    async def execute(self) -> Any:
+        """Execute data science workflow with memory compression.
+
+        This shows the full workflow:
+        1. Iterative loop with observe → evaluate → route → execute tools → memory compression
+        2. Final report generation with writer agent
+        """
+        self.update_printer("research", "Executing research workflow...")
+
+        return await self.run_iterative_loop(
+            iteration_body=self._iteration_step,
+            final_body=self._final_step
+        )
+
+    async def _iteration_step(self, iteration, group_id: str):
+        """Execute one iteration: observe → evaluate → route → tools → memory."""
+        # Step 1: Observe using behavior rendering
+        observe_instructions = self.context.render_behavior("observe", self.context.snapshot("observe"))
+        observe_result = await self.agent_step(
+            agent=self.observe_agent,
+            instructions=observe_instructions,
+            span_name="observe",
+            span_type="agent",
+            printer_key="observe",
+            printer_title="Observing",
+            printer_group_id=group_id,
+        )
+        observe_output = observe_result.final_output if hasattr(observe_result, 'final_output') else observe_result
+        self.context.apply_output("observe", observe_output)
+        iteration.observation = self._serialize_output(observe_output)
+        self._record_structured_payload(observe_output, context_label="observe")
+
+        # Step 2: Evaluate using behavior rendering
+        evaluate_instructions = self.context.render_behavior("evaluate", self.context.snapshot("evaluate"))
+        evaluate_result = await self.agent_step(
+            agent=self.evaluate_agent,
+            instructions=evaluate_instructions,
+            span_name="evaluate",
+            span_type="agent",
+            output_model=EvaluateOutput,
+            printer_key="evaluate",
+            printer_title="Evaluating",
+            printer_group_id=group_id,
+        )
+        evaluate_output = evaluate_result.final_output if hasattr(evaluate_result, 'final_output') else evaluate_result
+        self.context.apply_output("evaluate", evaluate_output)
+        self._record_structured_payload(evaluate_output, context_label="evaluate")
+
+        # Step 3: Route to appropriate tools if not complete
+        if not self.state.complete:
+            routing_instructions = self.context.render_behavior("route", self.context.snapshot("route"))
+            routing_result = await self.agent_step(
+                agent=self.routing_agent,
+                instructions=routing_instructions,
+                span_name="routing",
+                span_type="agent",
+                output_model=AgentSelectionPlan,
+                printer_key="routing",
+                printer_title="Routing",
+                printer_group_id=group_id,
+            )
+            routing_output = routing_result.final_output if hasattr(routing_result, 'final_output') else routing_result
+            self.context.apply_output("route", routing_output)
+            self._record_structured_payload(routing_output, context_label="routing")
+
+            # Step 4: Execute selected tools in parallel
+            await self._execute_tools(routing_output, self.tool_agents, group_id)
+
+        # Step 5: Memory compression (if needed)
+        if not self.state.complete and bool(self.state.unsummarized_history()):
+            memory_instructions = self.context.render_behavior("memory", self.context.snapshot("memory"))
+            memory_result = await self.agent_step(
+                agent=self.memory_agent,
+                instructions=memory_instructions,
+                span_name="memory",
+                span_type="agent",
+                output_model=MemoryAgentOutput,
+                printer_key="memory",
+                printer_title="Memory Compression",
+                printer_group_id=group_id,
+            )
+            memory_output = memory_result.final_output if hasattr(memory_result, 'final_output') else memory_result
+            self.context.apply_output("memory", memory_output)
+            self._record_structured_payload(memory_output, context_label="memory")
+
+    async def _final_step(self, final_group: str):
+        """Generate final report using writer agent."""
+        self.update_printer("research", "Research workflow complete", is_done=True)
+
+        writer_instructions = self.context.render_behavior("writer", self.context.snapshot("writer"))
+        await self.agent_step(
+            agent=self.writer_agent,
+            instructions=writer_instructions,
+            span_name="writer",
+            span_type="agent",
+            printer_key="writer",
+            printer_title="Writing Report",
+            printer_group_id=final_group,
+        )

pipelines/simple.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from loguru import logger
+
+from agentz.agent.base import ContextAgent
+from agentz.profiles.base import load_all_profiles
+from pipelines.base import BasePipeline
+
+
+class SimplePipeline(BasePipeline):
+    """Simple two-agent pipeline: routing agent + single tool agent."""
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        # Load profiles for template rendering
+        self.profiles = load_all_profiles()
+        llm = self.config.llm.main_model
+
+        # Setup routing agent
+        self.routing_agent = ContextAgent.from_profile(self.profiles["routing"], llm)
+
+        # Setup single tool agent
+        self.tool_agent = ContextAgent.from_profile(self.profiles["data_analysis"], llm)
+
+    async def run(self):
+        """Run the simple pipeline with single-pass execution."""
+        logger.info(f"Data path: {self.config.data_path}")
+        logger.info(f"User prompt: {self.config.prompt}")
+
+        # Prepare query
+        query = self.prepare_query(
+            content=f"Task: {self.config.prompt}\n"
+                f"Dataset path: {self.config.data_path}\n"
+                "Analyze the data and provide insights"
+        )
+
+        # Route the task
+        # self.update_printer("route", "Routing task to agent...")
+        routing_instructions = self.profiles["routing"].render(
+            QUERY=query,
+            GAP="Route the query to the data_analysis_agent",
+            HISTORY=""
+        )
+        selection_plan = await self.agent_step(
+            agent=self.routing_agent,
+            instructions=routing_instructions,
+            span_name="route_task",
+            span_type="agent",
+            output_model=self.routing_agent.output_type,
+            printer_key="route",
+            printer_title="Routing",
+        )
+        # self.update_printer("route", "Task routed", is_done=True)
+
+        # Execute the tool agent
+        task = selection_plan.tasks[0]
+        # self.update_printer("tool", f"Executing {task.agent}...")
+        
+        # import ipdb
+        # ipdb.set_trace()
+
+        result = await self.agent_step(
+            agent=self.tool_agent,
+            instructions=task.model_dump_json(),
+            span_name=task.agent,
+            span_type="tool",
+            printer_key="tool",
+            printer_title=f"Tool: {task.agent}",
+        )
+        # import ipdb
+        # ipdb.set_trace()
+
+        # self.update_printer("tool", f"Completed {task.agent}", is_done=True)
+
+        logger.info("Simple pipeline completed")
+        return result
+    

pipelines/simple_browser.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from loguru import logger
+
+from agentz.agent.base import ContextAgent as Agent
+from agentz.profiles.base import load_all_profiles
+from pipelines.base import BasePipeline
+from agentz.mcp.manager import MCPManager, MCPServerSpec
+from agentz.mcp.patches import apply_browsermcp_close_patch
+
+
+class NullReporter:
+    """No-op reporter to disable report generation for this pipeline."""
+
+    def start(self, *_args, **_kwargs):  # noqa: D401 - intentionally blank
+        return None
+
+    def set_final_result(self, _result):  # noqa: D401 - intentionally blank
+        return None
+
+    def finalize(self):  # noqa: D401 - intentionally blank
+        return None
+
+    def print_terminal_report(self):  # noqa: D401 - intentionally blank
+        return None
+
+    def record_status_update(self, **_kwargs):  # noqa: D401 - intentionally blank
+        return None
+
+    def record_panel(self, **_kwargs):  # noqa: D401 - intentionally blank
+        return None
+
+    def record_group_start(self, **_kwargs):  # noqa: D401 - intentionally blank
+        return None
+
+    def record_group_end(self, **_kwargs):  # noqa: D401 - intentionally blank
+        return None
+
+    def record_agent_step_start(self, **_kwargs):  # noqa: D401 - intentionally blank
+        return None
+
+    def record_agent_step_end(self, **_kwargs):  # noqa: D401 - intentionally blank
+        return None
+
+
+class SimpleBrowserPipeline(BasePipeline):
+    """Simple two-agent pipeline: routing agent + single tool agent."""
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        # Ensure Browser MCP stdio server has patched close handler to avoid recursion errors.
+        apply_browsermcp_close_patch()
+
+        # Disable report generation for this pipeline
+        self.reporter = NullReporter()
+
+        # Load profiles for template rendering
+        self.profiles = load_all_profiles()
+        llm = self.config.llm.main_model
+
+        # Setup routing agent
+        self.routing_agent = Agent.from_profile(self.profiles["routing"], llm)
+
+        # Setup single tool agent
+        self.tool_agent = None
+        mcp_config = getattr(self.config, "mcp", None)
+        self.mcp_manager = MCPManager.from_config(mcp_config)
+        self.mcp_manager.ensure_server(
+            "browser",
+            MCPServerSpec(
+                type="stdio",
+                options={
+                    "name": "Browser",
+                    "params": {"command": "npx", "args": ["-y", "@browsermcp/mcp@latest"]},
+                },
+            ),
+        )
+
+    async def run(self):
+        """Run the simple pipeline with single-pass execution to validate the browser agent."""
+        logger.info(f"User prompt: {self.config.prompt}")
+
+        async with self.mcp_manager.session() as mcp_session:
+            server = await mcp_session.get_server("browser")
+            self.tool_agent = Agent(
+                name="Browser",
+                instructions=f"""
+                    You are a browser agent. Your task is to interact with the browser following the instructions provided.
+                    """,
+                mcp_servers=[server],
+                model=self.config.llm.main_model,
+                # output_type=ToolAgentOutput if model_supports_json_and_tool_calls(self.config.llm.main_model) else None,
+                # output_parser=create_type_parser(ToolAgentOutput) if not model_supports_json_and_tool_calls(self.config.llm.main_model) else None
+            )
+
+        
+
+            # Prepare query
+            query = self.prepare_query(
+                content=f"Task: {self.config.prompt}\n"
+            )
+
+            # Route the task
+            # self.update_printer("route", "Routing task to agent...")
+            routing_instructions = self.profiles["routing"].render(
+                QUERY=query,
+                GAP="Route the query to the browser_agent",
+                HISTORY=""
+            )
+            selection_plan = await self.agent_step(
+                agent=self.routing_agent,
+                instructions=routing_instructions,
+                span_name="route_task",
+                span_type="agent",
+                output_model=self.routing_agent.output_type,
+                printer_key="route",
+                printer_title="Routing",
+            )
+            # self.update_printer("route", "Task routed", is_done=True)
+
+            # Execute the tool agent
+            task = selection_plan.tasks[0]
+            print(task)
+            # self.update_printer("tool", f"Executing {task.agent}...")
+            
+            # import ipdb
+            # ipdb.set_trace()
+
+            result = await self.agent_step(
+                agent=self.tool_agent,
+                instructions=task.model_dump_json(),
+                span_name=task.agent,
+                span_type="tool",
+                printer_key="tool",
+                printer_title=f"Tool: {task.agent}",
+            )
+            # import ipdb
+            # ipdb.set_trace()
+
+            # self.update_printer("tool", f"Completed {task.agent}", is_done=True)
+
+            logger.info("Simple browser pipeline completed")
+            return result
+        

pipelines/simple_chrome.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from loguru import logger
+
+from agentz.agent.base import ContextAgent
+from agentz.profiles.base import load_all_profiles
+from pipelines.base import BasePipeline
+
+
+class SimpleChromePipeline(BasePipeline):
+    """Simple two-agent pipeline: routing agent + single tool agent."""
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        # Load profiles for template rendering
+        self.profiles = load_all_profiles()
+        llm = self.config.llm.main_model
+
+        # Setup routing agent
+        self.routing_agent = ContextAgent.from_profile(self.profiles["routing"], llm)
+
+        # Setup single tool agent
+        self.tool_agent = ContextAgent.from_profile(self.profiles["chrome"], llm)
+
+    async def run(self):
+        """Run the simple pipeline with single-pass execution to validate the chrome agent."""
+        logger.info(f"User prompt: {self.config.prompt}")
+
+        # Prepare query
+        query = self.prepare_query(
+            content=f"Task: {self.config.prompt}\n"
+        )
+
+        # Route the task
+        # self.update_printer("route", "Routing task to agent...")
+        routing_instructions = self.profiles["routing"].render(
+            QUERY=query,
+            GAP="Route the query to the chrome_agent",
+            HISTORY=""
+        )
+        selection_plan = await self.agent_step(
+            agent=self.routing_agent,
+            instructions=routing_instructions,
+            span_name="route_task",
+            span_type="agent",
+            output_model=self.routing_agent.output_type,
+            printer_key="route",
+            printer_title="Routing",
+        )
+        # self.update_printer("route", "Task routed", is_done=True)
+
+        # Execute the tool agent
+        task = selection_plan.tasks[0]
+        # self.update_printer("tool", f"Executing {task.agent}...")
+        
+        # import ipdb
+        # ipdb.set_trace()
+
+        result = await self.agent_step(
+            agent=self.tool_agent,
+            instructions=task.model_dump_json(),
+            span_name=task.agent,
+            span_type="tool",
+            printer_key="tool",
+            printer_title=f"Tool: {task.agent}",
+        )
+        # import ipdb
+        # ipdb.set_trace()
+
+        # self.update_printer("tool", f"Completed {task.agent}", is_done=True)
+
+        logger.info("Simple chrome pipeline completed")
+        return result
+    

pipelines/simple_notion.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from loguru import logger
+
+from agentz.agent.base import ContextAgent as Agent
+from agentz.profiles.base import load_all_profiles
+from pipelines.base import BasePipeline
+from agentz.profiles.base import ToolAgentOutput
+from agentz.utils.config import BaseConfig
+from agentz.llm.llm_setup import model_supports_json_and_tool_calls
+from agentz.utils import create_type_parser
+from agents.mcp import MCPServer, MCPServerStdio, MCPServerSse
+
+
+async def get_notion_server():
+    async with MCPServerSse(
+        name = "Notion",
+        params = {
+            "url": "https://mcp.notion.com/mcp"
+        }
+    ) as server:
+        return server
+
+class SimpleNotionPipeline(BasePipeline):
+    """Simple two-agent pipeline: routing agent + single tool agent."""
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        # Load profiles for template rendering
+        self.profiles = load_all_profiles()
+        llm = self.config.llm.main_model
+
+        # Setup routing agent
+        self.routing_agent = Agent.from_profile(self.profiles["routing"], llm)
+
+        # Setup single tool agent
+        self.tool_agent = None
+
+    async def run(self):
+        """Run the simple pipeline with single-pass execution to validate the notion agent."""
+        logger.info(f"User prompt: {self.config.prompt}")
+
+
+        self.tool_agent = Agent(
+            name="Notion",
+            instructions=f"""
+                You are a notion agent. Your task is to interact with the notion following the instructions provided.
+                """,
+            mcp_servers=[await get_notion_server()],
+            model=self.config.llm.main_model,
+            output_type=ToolAgentOutput if model_supports_json_and_tool_calls(self.config.llm.main_model) else None,
+            output_parser=create_type_parser(ToolAgentOutput) if not model_supports_json_and_tool_calls(self.config.llm.main_model) else None
+        )
+
+        
+
+        # Prepare query
+        query = self.prepare_query(
+            content=f"Task: {self.config.prompt}\n"
+        )
+
+        # Route the task
+        # self.update_printer("route", "Routing task to agent...")
+        routing_instructions = self.profiles["routing"].render(
+            QUERY=query,
+            GAP="Route the query to the notion_agent",
+            HISTORY=""
+        )
+        selection_plan = await self.agent_step(
+            agent=self.routing_agent,
+            instructions=routing_instructions,
+            span_name="route_task",
+            span_type="agent",
+            output_model=self.routing_agent.output_type,
+            printer_key="route",
+            printer_title="Routing",
+        )
+        # self.update_printer("route", "Task routed", is_done=True)
+
+        # Execute the tool agent
+        task = selection_plan.tasks[0]
+        # self.update_printer("tool", f"Executing {task.agent}...")
+        
+        # import ipdb
+        # ipdb.set_trace()
+
+        result = await self.agent_step(
+            agent=self.tool_agent,
+            instructions=task.model_dump_json(),
+            span_name=task.agent,
+            span_type="tool",
+            printer_key="tool",
+            printer_title=f"Tool: {task.agent}",
+        )
+        # import ipdb
+        # ipdb.set_trace()
+
+        # self.update_printer("tool", f"Completed {task.agent}", is_done=True)
+
+        logger.info("Simple notion pipeline completed")
+        return result
+