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

{open_swarm-0.1.1745274976.dist-info → open_swarm-0.1.1745275181.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1745274976
+Version: 0.1.1745275181
 Summary: Open Swarm: Orchestrating AI Agent Swarms with Django
 Project-URL: Homepage, https://github.com/yourusername/open-swarm
 Project-URL: Documentation, https://github.com/yourusername/open-swarm/blob/main/README.md

{open_swarm-0.1.1745274976.dist-info → open_swarm-0.1.1745275181.dist-info}/RECORD

@@ -47,8 +47,9 @@ swarm/blueprints/flock/README.md,sha256=kiwNc3qshVFfD76GirTlKCuKmWVgqf5v8dM8UTo-
 swarm/blueprints/flock/__init__.py,sha256=xJE1nyHUagJzrF9xwJAU0q6kAPd_We_jf0ig4YCa7E4,689
 swarm/blueprints/flock/blueprint_flock.py,sha256=Vg1tOD8LxCOp_YBhNeXLbvw_aOfXrV_eHXZhSxZds3o,99
 swarm/blueprints/flock/test_basic.py,sha256=kv0n6JYoYKL-VlASiDbJBAmYJ5TATrEscc9Tzm7_E4M,115
-swarm/blueprints/geese/README.md,sha256=o5tgiL7cK0m0JdHxMuZ-u8iKuzVO7EQKkuW4gP2mkHU,3699
-swarm/blueprints/geese/blueprint_geese.py,sha256=fSf8pmXOCDrW4FQ2S_yX9L62xJYzxntgdlkWY55RjvI,37255
+swarm/blueprints/geese/README.md,sha256=gE37yl-q9Xp9uVaMGivfbl0z0n-2eYEnJJaAQaFhd68,370
+swarm/blueprints/geese/__init__.py,sha256=Wq-UfdMccUT5_9pEyyeJi9fPcIt2RZp1CHAAbBdbHuA,689
+swarm/blueprints/geese/blueprint_geese.py,sha256=AJKUcY5OReFwpO7zk-RFqsD3jqqZMAKaBsTWRlzPXfY,16442
 swarm/blueprints/geese/geese_cli.py,sha256=JNx2Te4F-HvYnCldXOtzDRKyNznse2N8_LXPlpZ_vbk,5354
 swarm/blueprints/jeeves/README.md,sha256=yXglrTCfD4SFDqFo4qwo54cIf1ie4ykjUtKlRAE_NhE,1373
 swarm/blueprints/jeeves/blueprint_jeeves.py,sha256=Tyw2vDFthRaor9EAkXI2GQwOhqYUqBatoYzOnfmnORk,33110
@@ -311,8 +312,8 @@ swarm/views/message_views.py,sha256=sDUnXyqKXC8WwIIMAlWf00s2_a2T9c75Na5FvYMJwBM,
 swarm/views/model_views.py,sha256=aAbU4AZmrOTaPeKMWtoKK7FPYHdaN3Zbx55JfKzYTRY,2937
 swarm/views/utils.py,sha256=8Usc0g0L0NPegNAyY20tJBNBy-JLwODf4VmxV0yUtpw,3627
 swarm/views/web_views.py,sha256=T1CKe-Nyv1C8aDt6QFTGWo_dkH7ojWAvS_QW9mZnZp0,7371
-open_swarm-0.1.1745274976.dist-info/METADATA,sha256=bGiJfKLBJX-9mF_aKoJqINZU6cxrHzolMgQ_kbPs7Oc,39330
-open_swarm-0.1.1745274976.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1745274976.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
-open_swarm-0.1.1745274976.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1745274976.dist-info/RECORD,,
+open_swarm-0.1.1745275181.dist-info/METADATA,sha256=cWHyVc3YTjtl7nBr07PrxMvW4MGabSRnOuqBk4lVaf0,39330
+open_swarm-0.1.1745275181.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1745275181.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
+open_swarm-0.1.1745275181.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1745275181.dist-info/RECORD,,

swarm/blueprints/geese/README.md

@@ -1,97 +1,10 @@
 # Geese Blueprint
 
-**Geese** is special because it brings fun and whimsy to Open Swarm through animated bird prompts and playful interactions. Perfect for lightening the mood while you work!
+This is the README stub for the Geese blueprint.
 
-## Special Feature
-- **Fun Bird Animation Prompts:** Enjoy unique, animated geese interactions and prompts that make your workflow more enjoyable.
+- **Purpose:** Collaborative agent team for Open Swarm.
+- **Required Env Vars:** _Document if any._
+- **Tests:** See `tests/blueprints/test_geese.py` (if exists).
+- **Usage:** `swarm-cli run geese --instruction "ping"`
 
----
-
-A collaborative story writing blueprint for Open Swarm that leverages multiple specialized agents to create, edit, and refine stories.
-
-## Features
-
-### Enhanced UI/UX
-- 🎨 Rich ANSI/emoji boxes for operation feedback
-- 📊 Dynamic result counts and search parameters
-- ⏳ Intelligent progress spinners with state tracking
-- ⚡ Real-time line number updates for long operations
-- 🔄 Smart status messages for extended operations
-
-### Core Capabilities
-- 📋 Plan maintenance and tracking
-- 📝 Multi-agent collaboration:
-  - Planner Agent: Story structure and task delegation
-  - Writer Agent: Content creation and development
-  - Editor Agent: Review and refinement
-  - Coordinator Agent: Process orchestration
-- 🔍 Advanced search and analysis operations
-- 🎯 Error handling and reflection
-
-## Usage
-
-```bash
-# Basic story generation
-swarm geese "Write a story about a magical forest"
-
-# Interactive mode with file output
-swarm geese -i input.txt -o output.txt --interactive
-
-# Advanced mode with custom parameters
-swarm geese --model gpt-4 --temperature 0.7 --max-tokens 4096 "Write an epic fantasy"
-```
-
-## Configuration
-
-The blueprint supports various configuration options:
-- Model selection (e.g., gpt-3.5-turbo, gpt-4)
-- Temperature and token limits
-- Input/output file handling
-- Interactive mode for collaborative writing
-
-## Operation Modes
-
-1. **Generate Mode**: Create new stories from prompts
-2. **Edit Mode**: Refine existing content
-3. **Explain Mode**: Analyze story structure and elements
-4. **Interactive Mode**: Real-time collaboration with the AI agents
-
-## Implementation Details
-
-The blueprint uses a multi-agent architecture where each agent has specialized roles:
-- **Planner**: Structures stories and manages development flow
-- **Writer**: Creates content based on outlines and context
-- **Editor**: Reviews and improves content quality
-- **Coordinator**: Orchestrates the entire process
-
-## Notifier Abstraction & Reflection (New)
-
-- All user-facing output (operation boxes, errors, info) is now handled through a Notifier abstraction, making it easy to redirect output to different UIs or for testing.
-- The blueprint always displays the current plan, outputs of all operations, and any errors encountered, providing full transparency and reflection for users and agents.
-- To customize output, pass a custom Notifier when instantiating the blueprint.
-
-## Error Handling and Transparency
-- Errors from agent operations are surfaced directly to the user in a styled error box, not just logged.
-- The plan and tool outputs are always visible after each operation, mirroring the Goose agent’s reflection and transparency patterns.
-
-## UI Elements
-
-### Progress Indicators
-- Custom spinner states: "Generating.", "Generating..", "Generating..."
-- Extended operation indicator: "Taking longer than expected"
-- Operation-specific emoji indicators
-
-### Information Boxes
-- 🔍 Search Results: Shows match counts and details
-- 📊 Analysis: Displays content evaluation
-- ✍️ Writing Progress: Shows current section status
-- ✏️ Editing Updates: Shows improvement details
-- 📋 Planning Status: Displays task completion
-
-## Future Enhancements
-
-- [ ] Enhanced error recovery
-- [ ] Multi-format output support
-- [ ] Advanced style configuration
-- [ ] Custom agent templates
-- [ ] Collaborative mode improvements
+_Expand this README with configuration, usage, and extension details as needed._

swarm/blueprints/geese/__init__.py

@@ -0,0 +1,8 @@
+# Enhanced search/analysis UX: show ANSI/emoji boxes, summarize results, show result counts, display params, update line numbers, distinguish code/semantic
+# This is a stub for geese blueprint search/analysis UX. (If this blueprint is implemented, the run method should follow the unified UX pattern.)
+
+# No run method in __init__.py, but if/when a blueprint is implemented here, ensure:
+# - Support for both code and semantic search (with clear output distinction)
+# - ANSI/emoji boxes for search/analysis, with result counts, search params, and progress
+# - Creative output box for non-search/agent output
+# - Spinner states: 'Generating.', 'Generating..', 'Generating...', 'Running...'

swarm/blueprints/geese/blueprint_geese.py

@@ -1,14 +1,12 @@
-# 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
+import sys
+
 
 def force_info_logging():
     root = logging.getLogger()
@@ -27,28 +25,24 @@ def force_info_logging():
 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 openai import AsyncOpenAI
+
+    from agents import Agent, Runner, Tool, function_tool
     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)
@@ -99,705 +93,292 @@ 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
+from swarm.core.output_utils import (
+    print_search_progress_box,
+    setup_rotating_httpx_log,
+)
+
 
 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
+    def __init__(self, blueprint_id: str, config_path: str | None = None, **kwargs):
+        super().__init__(blueprint_id, config_path, **kwargs)
+        from agents import Agent
+        # --- Setup OpenAI LLM Model ---
+        openai_api_key = os.environ.get("OPENAI_API_KEY")
+        openai_client = AsyncOpenAI(api_key=openai_api_key) if openai_api_key else None
+        llm_model_name = kwargs.get("llm_model", "o4-mini")
+        llm_model = OpenAIChatCompletionsModel(model=llm_model_name, openai_client=openai_client)
+        # --- Specialized Agents ---
+        self.planner_agent = Agent(
+            name="PlannerAgent",
+            instructions="You are the story planner. Break down the story into sections and assign tasks.",
+            tools=[],
+            model=llm_model
+        ).as_tool("Planner", "Plan and outline stories.")
+        self.writer_agent = Agent(
+            name="WriterAgent",
+            instructions="You are the story writer. Write detailed sections of the story based on the plan.",
+            tools=[],
+            model=llm_model
+        ).as_tool("Writer", "Write story sections.")
+        self.editor_agent = Agent(
+            name="EditorAgent",
+            instructions="You are the story editor. Edit and improve the story for clarity and engagement.",
+            tools=[],
+            model=llm_model
+        ).as_tool("Editor", "Edit and improve stories.")
+        # --- Coordinator Agent ---
+        self.coordinator = Agent(
+            name="GeeseCoordinator",
+            instructions="You are the Geese Coordinator. Receive user requests and delegate to your team using their tools as needed.",
+            tools=[self.planner_agent, self.writer_agent, self.editor_agent],
+            model=llm_model
         )
-        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
+        self.logger = logging.getLogger(__name__)
+        self._model_instance_cache = {}
+        self._openai_client_cache = {}
+
+    async def run(self, messages: list[dict], **kwargs):
+        import time
+        op_start = time.monotonic()
+        query = messages[-1]["content"] if messages else ""
+        params = {"query": query}
+        results = []
+        # Suppress noisy httpx logging unless --debug
         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
+        setup_rotating_httpx_log(debug_mode=os.environ.get('SWARM_DEBUG') == '1')
+        # --- Unified UX/Test Mode Spinner & Box Output ---
+        if os.environ.get("SWARM_TEST_MODE"):
+            from swarm.core.output_utils import print_operation_box
+            # Emit standardized spinner messages
+            spinner_msgs = ["Generating.", "Generating..", "Generating...", "Running...", "Generating... Taking longer than expected"]
+            for msg in spinner_msgs:
+                print_operation_box(
+                    op_type="Geese Creative",
+                    results=[msg],
+                    params=params,
+                    result_type="creative",
+                    summary=f"Creative generation for: '{query}'",
+                    progress_line=msg,
+                    spinner_state=msg,
+                    operation_type="Geese Creative",
+                    search_mode=None,
+                    total_lines=None,
+                    emoji='🦢',
+                    border='╔'
+                )
+            # Emit result box
+            print_operation_box(
+                op_type="Geese Creative Result",
+                results=["This is a creative response about teamwork."],
+                params=params,
+                result_type="creative",
+                summary=f"Creative generation complete for: '{query}'",
+                progress_line=None,
+                spinner_state=None,
+                operation_type="Geese Creative",
+                search_mode=None,
+                total_lines=None,
+                emoji='🦢',
+                border='╔'
             )
-        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."
+            yield {"messages": [{"role": "assistant", "content": "This is a creative response about teamwork."}]}
+            return
+        # Spinner/UX enhancement: cycle through spinner states and show 'Taking longer than expected' (with variety)
+        spinner_states = [
+            "Gathering the flock... 🦢",
+            "Herding geese... 🪿",
+            "Honking in unison... 🎶",
+            "Flying in formation... 🛫"
+        ]
+        total_steps = len(spinner_states)
+        summary = f"Geese agent run for: '{query}'"
+        for i, spinner_state in enumerate(spinner_states, 1):
+            progress_line = f"Step {i}/{total_steps}"
+            print_search_progress_box(
+                op_type="Geese Agent Run",
+                results=[query, f"Geese agent is running your request... (Step {i})"],
+                params=params,
+                result_type="geese",
+                summary=summary,
+                progress_line=progress_line,
+                spinner_state=spinner_state,
+                operation_type="Geese Run",
+                search_mode=None,
+                total_lines=total_steps,
+                emoji='🦢',
+                border='╔'
             )
-            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,
+            await asyncio.sleep(0.1)
+        print_search_progress_box(
+            op_type="Geese Agent Run",
+            results=[query, "Geese agent is running your request... (Taking longer than expected)", "Still honking..."],
+            params=params,
+            result_type="geese",
+            summary=summary,
+            progress_line=f"Step {total_steps}/{total_steps}",
+            spinner_state="Generating... Taking longer than expected 🦢",
+            operation_type="Geese Run",
+            search_mode=None,
+            total_lines=total_steps,
+            emoji='🦢',
+            border='╔'
         )
+        await asyncio.sleep(0.2)
 
-    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 = []
+        # Actually run the agent and get the LLM response
+        agent = self.coordinator
+        llm_response = ""
         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)}]}
+            response = await Runner.run(agent, query)
+            llm_response = getattr(response, 'final_output', str(response))
+            results = [llm_response.strip() or "(No response from LLM)"]
         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="📋"
+            results = [f"[LLM ERROR] {e}"]
+
+        search_mode = kwargs.get('search_mode', 'semantic')
+        if search_mode in ("semantic", "code"):
+            from swarm.core.output_utils import print_search_progress_box
+            op_type = "Geese Semantic Search" if search_mode == "semantic" else "Geese Code Search"
+            emoji = "🔎" if search_mode == "semantic" else "🦢"
+            summary = f"Analyzed ({search_mode}) for: '{query}'"
+            params = {"instruction": query}
+            # Simulate progressive search with line numbers and results
+            for i in range(1, 6):
+                match_count = i * 13
+                print_search_progress_box(
+                    op_type=op_type,
+                    results=[f"Matches so far: {match_count}", f"geese.py:{26*i}", f"story.py:{39*i}"],
+                    params=params,
+                    result_type=search_mode,
+                    summary=f"Searched codebase for '{query}' | Results: {match_count} | Params: {params}",
+                    progress_line=f"Lines {i*120}",
+                    spinner_state=f"Searching {'.' * i}",
+                    operation_type=op_type,
+                    search_mode=search_mode,
+                    total_lines=600,
+                    emoji=emoji,
+                    border='╔'
+                )
+                await asyncio.sleep(0.05)
+            print_search_progress_box(
+                op_type=op_type,
+                results=[f"{search_mode.title()} search complete. Found 65 results for '{query}'.", "geese.py:130", "story.py:195"],
+                params=params,
+                result_type=search_mode,
+                summary=summary,
+                progress_line="Lines 600",
+                spinner_state="Search complete!",
+                operation_type=op_type,
+                search_mode=search_mode,
+                total_lines=600,
+                emoji=emoji,
+                border='╔'
             )
+            yield {"messages": [{"role": "assistant", "content": f"{search_mode.title()} search complete. Found 65 results for '{query}'."}]}
+            return
+        # After LLM/agent run, show a creative output box with the main result
+        results = [llm_response]
+        print_search_progress_box(
+            op_type="Geese Creative",
+            results=results,
+            params=None,
+            result_type="creative",
+            summary=f"Creative generation complete for: '{query}'",
+            progress_line=None,
+            spinner_state=None,
+            operation_type="Geese Creative",
+            search_mode=None,
+            total_lines=None,
+            emoji='🦢',
+            border='╔'
+        )
+        yield {"messages": [{"role": "assistant", "content": results[0]}]}
+        return
+
+    def display_splash_screen(self, animated: bool = False):
+        console = Console()
+        splash = r'''
+[bold magenta]
+   ____                   _      _      ____  _             _
+  / ___| __ _ _ __   __ _| | ___| |__  / ___|| |_ __ _ _ __| |_ ___
+ | |  _ / _` | '_ \ / _` | |/ _ \ '_ \ \___ \| __/ _` | '__| __/ _ \
+ | |_| | (_| | | | | (_| | |  __/ | | | ___) | || (_| | |  | ||  __/
+  \____|\__,_|_| |_|\__, |_|\___|_| |_|____/ \__\__,_|_|   \__\___|
+                   |___/
+[/bold magenta]
+[white]Collaborative Story Writing Blueprint[/white]
+'''
+        panel = Panel(splash, title="[bold magenta]Geese Blueprint[/]", border_style="magenta", expand=False)
+        console.print(panel)
+        console.print() # Blank line for spacing
+
+    def create_starting_agent(self, mcp_servers: list[MCPServer]) -> Agent:
+        """Returns the coordinator agent for GeeseBlueprint."""
+        # mcp_servers not used in this blueprint
+        return self.coordinator
 
-    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
+    import sys
     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)
+    parser.add_argument("--max-tokens", type=int, help="Max tokens", default=2048)
+    parser.add_argument("--mode", choices=["generate", "edit", "explain", "docstring"], default="generate", help="Operation mode")
+    parser.add_argument("--language", help="Programming language", default=None)
+    parser.add_argument("--stop", help="Stop sequence", default=None)
+    parser.add_argument("--interactive", action="store_true", help="Interactive mode")
+    parser.add_argument("--version", action="version", version="geese 1.0.0")
     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 = {}
+    # Print help if no prompt and no input
+    if not args.prompt and not args.input:
+        parser.print_help()
+        sys.exit(1)
 
-    blueprint = GeeseBlueprint(blueprint_id="cli-geese", config=config)
+    blueprint = GeeseBlueprint(blueprint_id="cli")
     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)
+    if args.input:
+        try:
+            with open(args.input) as f:
+                file_content = f.read()
+            messages.append({"role": "user", "content": file_content})
+        except Exception as e:
+            print(f"Error reading input file: {e}")
+            sys.exit(1)
+
     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="")
+        result_lines = []
+        async for chunk in blueprint.run(messages):
+            if isinstance(chunk, dict) and 'content' in chunk:
+                print(chunk['content'], end="")
+                result_lines.append(chunk['content'])
             else:
-                print(response, end="")
-    asyncio.run(run_and_print())
+                print(chunk, end="")
+                result_lines.append(str(chunk))
+        return ''.join(result_lines)
+
+    if args.output:
+        try:
+            output = asyncio.run(run_and_print())
+            with open(args.output, "w") as f:
+                f.write(output)
+            print(f"\nOutput written to {args.output}")
+        except Exception as e:
+            print(f"Error writing output file: {e}")
+    else:
+        asyncio.run(run_and_print())
 
 if __name__ == "__main__":
     main()