open-swarm 0.1.1745274976__py3-none-any.whl → 0.1.1748636259__py3-none-any.whl

swarm/blueprints/geese/blueprint_geese.py

@@ -1,803 +0,0 @@
-# SECURITY WARNING: All future log/print statements that output environment variables or config values MUST use redact_sensitive_data or similar redaction utility. Never print or log secrets directly.
-
-import os
-import time
-from dotenv import load_dotenv; load_dotenv(override=True)
-
-import logging
-logging.basicConfig(level=logging.INFO, format='[%(levelname)s] %(name)s: %(message)s')
-import sys
-from swarm.utils.redact import redact_sensitive_data
-import asyncio
-
-def force_info_logging():
-    root = logging.getLogger()
-    for handler in root.handlers[:]:
-        root.removeHandler(handler)
-    loglevel = os.environ.get('LOGLEVEL', None)
-    debug_env = os.environ.get('SWARM_DEBUG', '0') == '1'
-    debug_arg = '--debug' in sys.argv
-    if debug_arg or debug_env or (loglevel and loglevel.upper() == 'DEBUG'):
-        level = logging.DEBUG
-    else:
-        level = logging.INFO
-    logging.basicConfig(level=level, format='[%(levelname)s] %(name)s: %(message)s')
-    root.setLevel(level)
-
-force_info_logging()
-
-import argparse
-from typing import List, Dict, Any, Optional, ClassVar
-
-project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
-src_path = os.path.join(project_root, 'src')
-if src_path not in sys.path: sys.path.insert(0, src_path)
-
-from typing import Optional
-from pathlib import Path
-try:
-    from agents import Agent, Tool, function_tool, Runner
-    from agents.mcp import MCPServer
-    from agents.models.interface import Model
-    from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
-    from openai import AsyncOpenAI
-    from swarm.core.blueprint_base import BlueprintBase
-    from swarm.core.blueprint_runner import BlueprintRunner
-except ImportError as e:
-    print(f"ERROR: Import failed in blueprint_geese: {e}. Check 'openai-agents' install and project structure.")
-    print(f"sys.path: {sys.path}")
-    sys.exit(1)
-
-import argparse
-
-def setup_logging():
-    parser = argparse.ArgumentParser(add_help=False)
-    parser.add_argument('--debug', action='store_true', help='Enable debug logging')
-    args, _ = parser.parse_known_args()
-    loglevel = os.environ.get('LOGLEVEL', None)
-    if args.debug or os.environ.get('SWARM_DEBUG', '0') == '1' or (loglevel and loglevel.upper() == 'DEBUG'):
-        logging.basicConfig(level=logging.DEBUG)
-    else:
-        logging.basicConfig(level=logging.INFO)
-    return args
-
-args = setup_logging()
-
-logger = logging.getLogger(__name__)
-
-# --- Tools ---
-def _create_story_outline(topic: str) -> str:
-    logger.info(f"Tool: Generating outline for: {topic}")
-    outline = f"Story Outline for '{topic}':\n1. Beginning: Introduce characters and setting.\n2. Middle: Develop conflict and rising action.\n3. Climax: The peak of the conflict.\n4. End: Resolution and aftermath."
-    logger.debug(f"Generated outline: {outline}")
-    return outline
-
-@function_tool
-def create_story_outline(topic: str) -> str:
-    """Generates a basic story outline based on a topic."""
-    return _create_story_outline(topic)
-
-def _write_story_part(part_name: str, outline: str, previous_parts: str) -> str:
-    logger.info(f"Tool: Writing story part: {part_name}")
-    content = f"## {part_name}\n\nThis is the draft content for the '{part_name}' section. It follows:\n'{previous_parts[:100]}...' \nIt should align with the outline:\n'{outline}'"
-    logger.debug(f"Generated content for {part_name}: {content[:100]}...")
-    return content
-
-@function_tool
-def write_story_part(part_name: str, outline: str, previous_parts: str) -> str:
-    """Writes a specific part of the story using the outline and previous context."""
-    return _write_story_part(part_name, outline, previous_parts)
-
-def _edit_story(full_story: str, edit_instructions: str) -> str:
-    logger.info(f"Tool: Editing story with instructions: {edit_instructions}")
-    edited_content = f"*** Edited Story Draft ***\n(Based on instructions: '{edit_instructions}')\n\n{full_story}\n\n[Editor's Notes: Minor tweaks applied for flow.]"
-    logger.debug("Editing complete.")
-    return edited_content
-
-@function_tool
-def edit_story(full_story: str, edit_instructions: str) -> str:
-    """Edits the complete story based on instructions."""
-    return _edit_story(full_story, edit_instructions)
-
-@function_tool
-def read_file(path: str, encoding: Optional[str] = "utf-8") -> str:
-    """Read and return the contents of a file."""
-    try:
-        with open(path, "r", encoding=encoding) as f:
-            content = f.read()
-        logger.info(f"Tool: Read file '{path}' ({len(content)} bytes)")
-        return content
-    except Exception as e:
-        logger.error(f"Tool: Failed to read file '{path}': {e}")
-        return f"[ERROR] Could not read file '{path}': {e}"
-
-@function_tool
-def write_file(path: str, content: str, encoding: Optional[str] = "utf-8") -> str:
-    """Write content to a file, overwriting if it exists."""
-    try:
-        with open(path, "w", encoding=encoding) as f:
-            f.write(content)
-        logger.info(f"Tool: Wrote file '{path}' ({len(content)} bytes)")
-        return f"[SUCCESS] Wrote file '{path}' ({len(content)} bytes)"
-    except Exception as e:
-        logger.error(f"Tool: Failed to write file '{path}': {e}")
-        return f"[ERROR] Could not write file '{path}': {e}"
-
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from rich.live import Live
-from rich import box
-import asyncio
-from enum import Enum
-from swarm.ux.ansi_box import ansi_box
-from dataclasses import dataclass
-
-# --- Spinner State Constants ---
-SPINNER_STATES = [
-    "Generating.",
-    "Generating..",
-    "Generating...",
-    "Running...",
-]
-SLOW_SPINNER = "Generating... Taking longer than expected"
-
-class SpinnerState(Enum):
-    GENERATING_1 = "Generating."
-    GENERATING_2 = "Generating.."
-    GENERATING_3 = "Generating..."
-    RUNNING = "Running..."
-    LONG_WAIT = "Generating... Taking longer than expected"
-
-# --- Notifier abstraction ---
-class Notifier:
-    def __init__(self, console=None):
-        from rich.console import Console
-        self.console = console or Console()
-
-    def print_box(self, title, content, style="blue", *, result_count: int = None, params: dict = None, op_type: str = None, progress_line: int = None, total_lines: int = None, spinner_state: str = None, emoji: str = None):
-        emoji_map = {
-            "search": "🔍",
-            "code_search": "💻",
-            "semantic_search": "🧠",
-            "analysis": "📊",
-            "writing": "✍️",
-            "editing": "✏️",
-            "planning": "📋"
-        }
-        emoji = emoji_map.get(op_type or title.lower(), emoji or "💡")
-        summary_lines = []
-        if result_count is not None:
-            summary_lines.append(f"Results: {result_count}")
-        if params:
-            for k, v in params.items():
-                summary_lines.append(f"{k.title()}: {v}")
-        if progress_line and total_lines:
-            summary_lines.append(f"Progress: {progress_line}/{total_lines}")
-        summary = "\n".join(summary_lines)
-        box_content = content
-        if summary:
-            box_content = f"{summary}\n{content}"
-        if spinner_state:
-            box_content += f"\n{spinner_state}"
-        if emoji:
-            box_content = f"{emoji} {box_content}"
-        display_operation_box(
-            title=title,
-            content=box_content,
-            result_count=result_count,
-            params=params,
-            progress_line=progress_line,
-            total_lines=total_lines,
-            spinner_state=spinner_state,
-            emoji=emoji
-        )
-
-    def print_error(self, title, content):
-        self.print_box(title, content, style="red", emoji="❌")
-
-    def print_info(self, content):
-        self.console.print(content)
-
-@dataclass
-class AgentTool:
-    name: str
-    description: str
-    parameters: dict
-    handler: callable = None
-
-class ToolRegistry:
-    """
-    Central registry for all tools: both LLM (OpenAI function-calling) and Python-only tools.
-    """
-    def __init__(self):
-        self.llm_tools = {}
-        self.python_tools = {}
-
-    def register_llm_tool(self, name: str, description: str, parameters: dict, handler):
-        self.llm_tools[name] = {
-            'name': name,
-            'description': description,
-            'parameters': parameters,
-            'handler': handler
-        }
-
-    def register_python_tool(self, name: str, handler, description: str = ""):
-        self.python_tools[name] = handler
-
-    def get_llm_tools(self, as_openai_spec=False):
-        tools = list(self.llm_tools.values())
-        if as_openai_spec:
-            # Return OpenAI-compatible dicts
-            return [
-                {
-                    'name': t['name'],
-                    'description': t['description'],
-                    'parameters': t['parameters']
-                } for t in tools
-            ]
-        return tools
-
-    def get_python_tool(self, name: str):
-        return self.python_tools.get(name)
-
-from swarm.blueprints.common.operation_box_utils import display_operation_box
-
-class GeeseBlueprint(BlueprintBase):
-    """
-    Geese: Swarm-powered collaborative story writing blueprint.
-    """
-    metadata: ClassVar[dict] = {
-        "name": "GeeseBlueprint",
-        "cli_name": "geese",
-        "title": "Geese: Swarm-powered collaborative story writing agent",
-        "description": "A collaborative story writing blueprint leveraging multiple specialized agents to create, edit, and refine stories.",
-    }
-
-    def get_llm_profile_name(self):
-        # Returns the active LLM profile name, prioritizing CLI-set or fallback logic
-        if hasattr(self, '_llm_profile_name') and self._llm_profile_name:
-            return self._llm_profile_name
-        if hasattr(self, '_resolve_llm_profile'):
-            return self._resolve_llm_profile()
-        return 'default'
-
-    def get_llm_profile_config(self):
-        # Returns the config dict for the active LLM profile
-        profile = self.get_llm_profile_name()
-        llm_section = self.config.get('llm', {}) if hasattr(self, 'config') else {}
-        return llm_section.get(profile, llm_section.get('default', {}))
-
-    def get_model_name(self):
-        return self.get_llm_profile_config().get('model', 'gpt-4o')
-
-    def get_llm_endpoint(self):
-        return self.get_llm_profile_config().get('base_url', 'unknown')
-
-    def get_llm_api_key(self):
-        api_key = self.get_llm_profile_config().get('api_key', 'unknown')
-        import os
-        # Try to resolve env vars in api_key string
-        if isinstance(api_key, str) and api_key.startswith('${') and api_key.endswith('}'):
-            env_var = api_key[2:-1]
-            return os.environ.get(env_var, 'NOT SET')
-        return api_key
-
-    def __init__(self, blueprint_id: str = "geese", config=None, config_path=None, notifier=None, mcp_servers: Optional[Dict[str, Any]] = None, agent_mcp_assignments: Optional[Dict[str, list]] = None, **kwargs):
-        super().__init__(blueprint_id, config=config, config_path=config_path, **kwargs)
-        self.blueprint_id = blueprint_id
-        self.config_path = config_path
-        self._config = config if config is not None else {}
-        self._llm_profile_name = None
-        self._llm_profile_data = None
-        self._markdown_output = None
-        self.notifier = notifier
-        self.mcp_servers = mcp_servers or {}
-        self.agent_mcp_assignments = agent_mcp_assignments or {}
-        # Only call model/profile-dependent logic if config is set
-        if self._config is not None:
-            self.model_name = self.get_model_name()
-        else:
-            self.model_name = None
-        # Register required tools for delegation flow tests
-        self.tool_registry = ToolRegistry()  # Ensure tool_registry always exists
-        # Register required tools for delegation flow tests
-        self.tool_registry.register_llm_tool(
-            name="Planner",
-            description="Plans the story structure.",
-            parameters={},
-            handler=lambda *a, **kw: None
-        )
-        self.tool_registry.register_llm_tool(
-            name="Writer",
-            description="Writes story content.",
-            parameters={},
-            handler=lambda *a, **kw: None
-        )
-        self.tool_registry.register_llm_tool(
-            name="Editor",
-            description="Edits the story.",
-            parameters={},
-            handler=lambda *a, **kw: None
-        )
-        self.notifier = notifier or Notifier()
-        self.mcp_servers = mcp_servers or getattr(self, 'mcp_server_configs', {}) or {}
-        self.agent_mcp_assignments = agent_mcp_assignments or {}
-        # Build enabled/disabled lists for all MCPs
-        self.enabled_mcp_servers = {k: v for k, v in self.mcp_servers.items() if not v.get('disabled', False)}
-        from agents import Agent, Tool
-        from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
-        from openai import AsyncOpenAI
-        import os
-        if self.model_name:
-            model_name = self.model_name
-            api_key = os.environ.get('OPENAI_API_KEY')
-            openai_client = AsyncOpenAI(api_key=api_key)
-            model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=openai_client)
-        else:
-            model_instance = None
-        # Attach all available tools (LLM and Python) to the agent
-        llm_tools = getattr(self, 'tool_registry', None)
-        if llm_tools is not None:
-            # Use AgentTool objects for agent.tools
-            llm_tools = [AgentTool(**t) for t in llm_tools.get_llm_tools(as_openai_spec=False)]
-        else:
-            llm_tools = []
-        python_tools = getattr(self, 'tool_registry', None)
-        if python_tools is not None:
-            python_tools = python_tools.python_tools
-        else:
-            python_tools = {}
-        if model_instance:
-            agent = Agent(
-                name='GooseCoordinator',
-                model=model_instance,
-                instructions="You are a highly skilled code generation and automation agent.",
-                tools=llm_tools
-            )
-        else:
-            agent = Agent(
-                name='GooseCoordinator',
-                instructions="You are a highly skilled code generation and automation agent.",
-                tools=llm_tools
-            )
-        agent.python_tools = python_tools
-        # Restore legacy agent MCP assignment logic to satisfy agent_mcp_assignment tests
-        self.agents = {'GooseCoordinator': agent}
-        agent_names = set(self.agent_mcp_assignments.keys()) | {'GooseCoordinator'}
-        for agent_name in agent_names:
-            if agent_name == 'GooseCoordinator':
-                continue
-            assigned_mcps = self.agent_mcp_assignments.get(agent_name, [])
-            assigned_mcp_objs = [self.enabled_mcp_servers[m] for m in assigned_mcps if m in self.enabled_mcp_servers]
-            extra_agent = Agent(
-                name=agent_name,
-                tools=[],  # Minimal tools for test compatibility
-                model=model_instance,
-                instructions="Test agent for MCP assignment."
-            )
-            extra_agent.mcp_servers = assigned_mcp_objs
-            extra_agent.description = f"Agent {agent_name} for test MCP assignment."
-            self.agents[agent_name] = extra_agent
-        # Ensure MCP assignment for all agents in self.agents
-        for agent_name, mcp_names in self.agent_mcp_assignments.items():
-            agent = self.agents.get(agent_name)
-            if agent is not None:
-                agent.mcp_servers = [self.enabled_mcp_servers[m] for m in mcp_names if m in self.enabled_mcp_servers]
-        self.coordinator = agent
-        self.logger = logging.getLogger(__name__)
-        self.plan = []
-
-        # --- Directory/Folder and Grep Tools ---
-        import os, re
-        def list_folder(path: str = "."):
-            """List immediate contents of a directory (files and folders)."""
-            try:
-                return {"entries": os.listdir(path)}
-            except Exception as e:
-                return {"error": str(e)}
-
-        def list_folder_recursive(path: str = "."):
-            """List all files and folders recursively within a directory."""
-            results = []
-            try:
-                for root, dirs, files in os.walk(path):
-                    for d in dirs:
-                        results.append(os.path.join(root, d))
-                    for f in files:
-                        results.append(os.path.join(root, f))
-                return {"entries": results}
-            except Exception as e:
-                return {"error": str(e)}
-
-        def grep_search(pattern: str, path: str = ".", case_insensitive: bool = False, max_results: int = 100, progress_yield: int = 10):
-            """Progressive regex search in files, yields dicts of matches and progress."""
-            matches = []
-            import re, os
-            flags = re.IGNORECASE if case_insensitive else 0
-            try:
-                total_files = 0
-                for root, dirs, files in os.walk(path):
-                    for fname in files:
-                        total_files += 1
-                scanned_files = 0
-                for root, dirs, files in os.walk(path):
-                    for fname in files:
-                        fpath = os.path.join(root, fname)
-                        scanned_files += 1
-                        try:
-                            with open(fpath, "r", encoding="utf-8", errors="ignore") as f:
-                                for i, line in enumerate(f, 1):
-                                    if re.search(pattern, line, flags):
-                                        matches.append({
-                                            "file": fpath,
-                                            "line": i,
-                                            "content": line.strip()
-                                        })
-                                        if len(matches) >= max_results:
-                                            yield {"matches": matches, "progress": scanned_files, "total": total_files, "truncated": True, "done": True}
-                                            return
-                        except Exception:
-                            continue
-                        if scanned_files % progress_yield == 0:
-                            yield {"matches": matches.copy(), "progress": scanned_files, "total": total_files, "truncated": False, "done": False}
-                # Final yield
-                yield {"matches": matches, "progress": scanned_files, "total": total_files, "truncated": False, "done": True}
-            except Exception as e:
-                yield {"error": str(e), "matches": matches, "progress": scanned_files, "total": total_files, "truncated": False, "done": True}
-
-        self.tool_registry.register_llm_tool(
-            name="grep_search",
-            description="Search for a regex pattern in files under a directory tree. Returns file, line number, and line content for each match.",
-            parameters={
-                "type": "object",
-                "properties": {
-                    "pattern": {"type": "string", "description": "Regex pattern to search for"},
-                    "path": {"type": "string", "description": "Directory to search (default: current directory)"},
-                    "case_insensitive": {"type": "boolean", "description": "Case-insensitive search (default: false)"},
-                    "max_results": {"type": "integer", "description": "Maximum number of results (default: 100)"}
-                },
-                "required": ["pattern"]
-            },
-            handler=grep_search,
-        )
-        # Register agent/blueprint delegation tools (stubs)
-        def planner(prompt: str) -> str:
-            """Stub tool for planning."""
-            return "Planned: " + prompt
-        self.tool_registry.register_llm_tool(
-            name="Planner",
-            description="Plans the next steps for story generation.",
-            parameters={"type": "object", "properties": {"prompt": {"type": "string", "description": "Prompt to plan for"}}, "required": ["prompt"]},
-            handler=planner,
-        )
-        def writer(plan: str, context: str = "") -> str:
-            """Write story content based on a plan and optional context."""
-            return "[Writer] Wrote content for plan: " + plan
-        def editor(draft: str) -> str:
-            """Edit and refine a draft story."""
-            return "[Editor] Edited draft."
-        self.tool_registry.register_llm_tool(
-            name="Writer",
-            description="Write story content based on a plan and optional context.",
-            parameters={"type": "object", "properties": {"plan": {"type": "string", "description": "Story plan"}, "context": {"type": "string", "description": "Optional context"}}, "required": ["plan"]},
-            handler=writer,
-        )
-        self.tool_registry.register_llm_tool(
-            name="Editor",
-            description="Edit and refine a draft story.",
-            parameters={"type": "object", "properties": {"draft": {"type": "string", "description": "Draft story text"}}, "required": ["draft"]},
-            handler=editor,
-        )
-        # --- Directory/Folder and Grep Tools ---
-        import os, re
-        def list_folder(path: str = "."):
-            """List immediate contents of a directory (files and folders)."""
-            try:
-                return {"entries": os.listdir(path)}
-            except Exception as e:
-                return {"error": str(e)}
-
-        def list_folder_recursive(path: str = "."):
-            """List all files and folders recursively within a directory."""
-            results = []
-            try:
-                for root, dirs, files in os.walk(path):
-                    for d in dirs:
-                        results.append(os.path.join(root, d))
-                    for f in files:
-                        results.append(os.path.join(root, f))
-                return {"entries": results}
-            except Exception as e:
-                return {"error": str(e)}
-
-        def grep_search(pattern: str, path: str = ".", case_insensitive: bool = False, max_results: int = 100, progress_yield: int = 10):
-            """Progressive regex search in files, yields dicts of matches and progress."""
-            matches = []
-            flags = re.IGNORECASE if case_insensitive else 0
-            try:
-                total_files = 0
-                for root, dirs, files in os.walk(path):
-                    for fname in files:
-                        total_files += 1
-                scanned_files = 0
-                for root, dirs, files in os.walk(path):
-                    for fname in files:
-                        fpath = os.path.join(root, fname)
-                        scanned_files += 1
-                        try:
-                            with open(fpath, "r", encoding="utf-8", errors="ignore") as f:
-                                for i, line in enumerate(f, 1):
-                                    if re.search(pattern, line, flags):
-                                        matches.append({
-                                            "file": fpath,
-                                            "line": i,
-                                            "content": line.strip()
-                                        })
-                                        if len(matches) >= max_results:
-                                            yield {"matches": matches, "progress": scanned_files, "total": total_files, "truncated": True, "done": True}
-                                            return
-                        except Exception:
-                            continue
-                        if scanned_files % progress_yield == 0:
-                            yield {"matches": matches.copy(), "progress": scanned_files, "total": total_files, "truncated": False, "done": False}
-                # Final yield
-                yield {"matches": matches, "progress": scanned_files, "total": total_files, "truncated": False, "done": True}
-            except Exception as e:
-                yield {"error": str(e), "matches": matches, "progress": scanned_files, "total": total_files, "truncated": False, "done": True}
-
-        self.tool_registry.register_llm_tool(
-            name="grep_search",
-            description="Search for a regex pattern in files under a directory tree. Returns file, line number, and line content for each match.",
-            parameters={
-                "type": "object",
-                "properties": {
-                    "pattern": {"type": "string", "description": "Regex pattern to search for"},
-                    "path": {"type": "string", "description": "Directory to search (default: current directory)"},
-                    "case_insensitive": {"type": "boolean", "description": "Case-insensitive search (default: false)"},
-                    "max_results": {"type": "integer", "description": "Maximum number of results (default: 100)"}
-                },
-                "required": ["pattern"]
-            },
-            handler=grep_search,
-        )
-        # --- Directory/Folder and Grep Tools ---
-        import os, re
-        def list_folder(path: str = "."):
-            """List immediate contents of a directory (files and folders)."""
-            try:
-                return {"entries": os.listdir(path)}
-            except Exception as e:
-                return {"error": str(e)}
-
-        def list_folder_recursive(path: str = "."):
-            """List all files and folders recursively within a directory."""
-            results = []
-            try:
-                for root, dirs, files in os.walk(path):
-                    for d in dirs:
-                        results.append(os.path.join(root, d))
-                    for f in files:
-                        results.append(os.path.join(root, f))
-                return {"entries": results}
-            except Exception as e:
-                return {"error": str(e)}
-
-        def grep_search(pattern: str, path: str = ".", case_insensitive: bool = False, max_results: int = 100, progress_yield: int = 10):
-            """Progressive regex search in files, yields dicts of matches and progress."""
-            matches = []
-            flags = re.IGNORECASE if case_insensitive else 0
-            try:
-                total_files = 0
-                for root, dirs, files in os.walk(path):
-                    for fname in files:
-                        total_files += 1
-                scanned_files = 0
-                for root, dirs, files in os.walk(path):
-                    for fname in files:
-                        fpath = os.path.join(root, fname)
-                        scanned_files += 1
-                        try:
-                            with open(fpath, "r", encoding="utf-8", errors="ignore") as f:
-                                for i, line in enumerate(f, 1):
-                                    if re.search(pattern, line, flags):
-                                        matches.append({
-                                            "file": fpath,
-                                            "line": i,
-                                            "content": line.strip()
-                                        })
-                                        if len(matches) >= max_results:
-                                            yield {"matches": matches, "progress": scanned_files, "total": total_files, "truncated": True, "done": True}
-                                            return
-                        except Exception:
-                            continue
-                        if scanned_files % progress_yield == 0:
-                            yield {"matches": matches.copy(), "progress": scanned_files, "total": total_files, "truncated": False, "done": False}
-                # Final yield
-                yield {"matches": matches, "progress": scanned_files, "total": total_files, "truncated": False, "done": True}
-            except Exception as e:
-                yield {"error": str(e), "matches": matches, "progress": scanned_files, "total": total_files, "truncated": False, "done": True}
-
-        self.tool_registry.register_llm_tool(
-            name="grep_search",
-            description="Search for a regex pattern in files under a directory tree. Returns file, line number, and line content for each match.",
-            parameters={
-                "type": "object",
-                "properties": {
-                    "pattern": {"type": "string", "description": "Regex pattern to search for"},
-                    "path": {"type": "string", "description": "Directory to search (default: current directory)"},
-                    "case_insensitive": {"type": "boolean", "description": "Case-insensitive search (default: false)"},
-                    "max_results": {"type": "integer", "description": "Maximum number of results (default: 100)"}
-                },
-                "required": ["pattern"]
-            },
-            handler=grep_search,
-        )
-
-    async def run(self, messages: List[dict], **kwargs):
-        """Main execution entry point for the Geese blueprint."""
-        logger.info("GeeseBlueprint run method called.")
-        instruction = messages[-1].get("content", "") if messages else ""
-        from swarm.core.blueprint_ux import BlueprintUXImproved
-        ux = BlueprintUXImproved(style="serious")
-        spinner_idx = 0
-        start_time = time.time()
-        spinner_yield_interval = 1.0  # seconds
-        last_spinner_time = start_time
-        yielded_spinner = False
-        result_chunks = []
-        try:
-            from agents import Runner
-            runner_gen = Runner.run(self.create_starting_agent([]), instruction)
-            while True:
-                now = time.time()
-                try:
-                    chunk = next(runner_gen)
-                    result_chunks.append(chunk)
-                    # If chunk is a final result, wrap and yield
-                    if chunk and isinstance(chunk, dict) and "messages" in chunk:
-                        content = chunk["messages"][0]["content"] if chunk["messages"] else ""
-                        summary = ux.summary("Operation", len(result_chunks), {"instruction": instruction[:40]})
-                        box = ux.ansi_emoji_box(
-                            title="Geese Result",
-                            content=content,
-                            summary=summary,
-                            params={"instruction": instruction[:40]},
-                            result_count=len(result_chunks),
-                            op_type="run",
-                            status="success"
-                        )
-                        yield {"messages": [{"role": "assistant", "content": box}]}
-                    else:
-                        yield chunk
-                    yielded_spinner = False
-                except StopIteration:
-                    break
-                except Exception:
-                    if now - last_spinner_time >= spinner_yield_interval:
-                        taking_long = (now - start_time > 10)
-                        spinner_msg = ux.spinner(spinner_idx, taking_long=taking_long)
-                        yield {"messages": [{"role": "assistant", "content": spinner_msg}]}
-                        spinner_idx += 1
-                        last_spinner_time = now
-                        yielded_spinner = True
-            if not result_chunks and not yielded_spinner:
-                yield {"messages": [{"role": "assistant", "content": ux.spinner(0)}]}
-        except Exception as e:
-            logger.error(f"Error during Geese run: {e}", exc_info=True)
-            yield {"messages": [{"role": "assistant", "content": f"An error occurred: {e}"}]}
-
-    async def demo_run(self, messages: List[dict], **kwargs):
-        # --- DEMO: Progressive search for live operation box UX ---
-        import asyncio
-        prompt = messages[0].get('content', '') if messages else ''
-        # Simulate a progressive code search with fake results
-        total = 5  # test expects 5 updates
-        matches = []
-        for i in range(1, total + 1):
-            await asyncio.sleep(0.3)
-            matches.append(f"def demo_func_{i}(): ...")
-            chunk = {
-                "matches": matches.copy(),
-                "progress": i,
-                "total": total,
-                "truncated": False,
-                "done": i == total,
-                "query": prompt,
-                "type": "code_search"
-            }
-            display_operation_box(
-                title="Searching Filesystem" if chunk.get("progress") else "Geese Output",
-                content=f"Matches so far: {len(chunk.get('matches', []))}" if chunk.get("matches") is not None else str(chunk),
-                result_count=len(chunk.get('matches', [])) if chunk.get("matches") is not None else None,
-                params={k: v for k, v in chunk.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done'}},
-                progress_line=chunk.get('progress'),
-                total_lines=chunk.get('total'),
-                spinner_state=None,
-                emoji="🔍" if chunk.get("progress") else "💡",
-                op_type="search"
-            )
-            yield chunk
-
-    def display_plan_box(self):
-        if self.plan:
-            display_operation_box(
-                title="Planning Update",
-                content="\n".join([f"✓ {item}" for item in self.plan]),
-                emoji="📋"
-            )
-
-    def update_spinner(self, progress_state, elapsed_time):
-        # Use direct reference to SpinnerState to avoid import errors when running as __main__
-        from swarm.blueprints.geese.blueprint_geese import SpinnerState
-        if elapsed_time > 10 and progress_state in [SpinnerState.GENERATING_1, SpinnerState.GENERATING_2, SpinnerState.GENERATING_3]:
-            return SpinnerState.LONG_WAIT
-        return progress_state
-
-    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
-        """Returns the coordinator agent for GeeseBlueprint, using only assigned MCP servers."""
-        self.logger.info(f"Coordinator assigned MCP servers: {[m.get('name', 'unknown') for m in getattr(self.coordinator, 'mcp_servers', [])]}")
-        return self.agents['GooseCoordinator']
-
-# --- CLI entry point ---
-def main():
-    import argparse
-    import sys
-    import asyncio
-    import os
-    import json
-    parser = argparse.ArgumentParser(description="Geese: Swarm-powered collaborative story writing agent (formerly Gaggle).")
-    parser.add_argument("prompt", nargs="?", help="Prompt or story topic (quoted)")
-    parser.add_argument("-i", "--input", help="Input file or directory", default=None)
-    parser.add_argument("-o", "--output", help="Output file", default=None)
-    parser.add_argument("--model", help="Model name (codex, gpt, etc.)", default=None)
-    parser.add_argument("--temperature", type=float, help="Sampling temperature", default=0.1)
-    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
-    parser.add_argument("--config", help="Path to swarm_config.json", default=None)
-    args = parser.parse_args()
-
-    # Load config file if present
-    config_path = args.config or "/home/chatgpt/open-swarm/swarm_config.json"
-    config = None
-    if os.path.isfile(config_path):
-        with open(config_path, "r") as f:
-            config = json.load(f)
-    else:
-        print(f"WARNING: Config file not found at {config_path}. Proceeding with empty config.")
-        config = {}
-
-    blueprint = GeeseBlueprint(blueprint_id="cli-geese", config=config)
-    messages = []
-    if args.prompt:
-        messages.append({"role": "user", "content": args.prompt})
-    else:
-        print("Type your prompt (or 'exit' to quit):\n")
-        while True:
-            try:
-                user_input = input("You: ").strip()
-            except (EOFError, KeyboardInterrupt):
-                print("\nExiting Geese CLI.")
-                break
-            if user_input.lower() in {"exit", "quit", "q"}:
-                print("Goodbye!")
-                break
-            messages.append({"role": "user", "content": user_input})
-            async def run_and_print():
-                async for response in blueprint.run(messages, model=args.model):
-                    if isinstance(response, dict) and 'content' in response:
-                        print(response['content'], end="")
-                    else:
-                        print(response, end="")
-            asyncio.run(run_and_print())
-            messages = []
-        sys.exit(0)
-    async def run_and_print():
-        async for response in blueprint.run(messages, model=args.model):
-            if isinstance(response, dict) and 'content' in response:
-                print(response['content'], end="")
-            else:
-                print(response, end="")
-    asyncio.run(run_and_print())
-
-if __name__ == "__main__":
-    main()