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

swarm/blueprints/geese/blueprint_geese.py

@@ -1,384 +0,0 @@
-import os
-from dotenv import load_dotenv; load_dotenv(override=True)
-
-import logging
-
-logging.basicConfig(level=logging.INFO, format='[%(levelname)s] %(name)s: %(message)s')
-import asyncio
-import sys
-
-
-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
-
-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)
-
-try:
-    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 swarm.core.blueprint_base import BlueprintBase
-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)
-
-
-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)
-
-from rich.console import Console
-from rich.panel import Panel
-
-from swarm.core.output_utils import (
-    print_search_progress_box,
-    setup_rotating_httpx_log,
-)
-
-
-class GeeseBlueprint(BlueprintBase):
-    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.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
-        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='╔'
-            )
-            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='╔'
-            )
-            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)
-
-        # Actually run the agent and get the LLM response
-        agent = self.coordinator
-        llm_response = ""
-        try:
-            from agents import Runner
-            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:
-            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 main():
-    import argparse
-    import asyncio
-    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("--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()
-
-    # 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")
-    messages = []
-    if args.prompt:
-        messages.append({"role": "user", "content": args.prompt})
-    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():
-        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(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()

swarm/blueprints/geese/geese_cli.py

@@ -1,102 +0,0 @@
-import argparse
-from swarm.blueprints.geese.blueprint_geese import GeeseBlueprint
-
-def main():
-    parser = argparse.ArgumentParser(description="Run the Geese Blueprint")
-    parser.add_argument('--message', dest='prompt', nargs='?', default=None, help='Prompt for the agent (optional, aliased as --message for compatibility)')
-    parser.add_argument('--config', type=str, help='Path to config file', default=None)
-    parser.add_argument('--agent-mcp', action='append', help='Agent to MCP assignment, e.g. --agent-mcp agent1:mcpA,mcpB')
-    parser.add_argument('--model', type=str, help='Model name (overrides DEFAULT_LLM envvar)', default=None)
-    args = parser.parse_args()
-
-    agent_mcp_assignments = None
-    if args.agent_mcp:
-        agent_mcp_assignments = {}
-        for assignment in args.agent_mcp:
-            agent, mcps = assignment.split(':', 1)
-            agent_mcp_assignments[agent] = [m.strip() for m in mcps.split(',')]
-
-    blueprint = GeeseBlueprint(
-        blueprint_id='geese',
-        config_path=args.config,
-        agent_mcp_assignments=agent_mcp_assignments
-    )
-    import asyncio
-    messages = []
-    if args.prompt:
-        # PATCH: Always use blueprint.run for progressive UX
-        messages = [{"role": "user", "content": args.prompt}]
-        import asyncio
-        from swarm.blueprints.geese.blueprint_geese import SPINNER_STATES, SLOW_SPINNER, display_operation_box
-        import time
-        async def run_and_print():
-            spinner_idx = 0
-            spinner_start = time.time()
-            async for chunk in blueprint.run(messages, model=args.model):
-                if isinstance(chunk, dict) and (chunk.get("progress") or chunk.get("matches") or chunk.get("spinner_state")):
-                    elapsed = time.time() - spinner_start
-                    spinner_state = chunk.get("spinner_state")
-                    if not spinner_state:
-                        spinner_state = SLOW_SPINNER if elapsed > 10 else SPINNER_STATES[spinner_idx % len(SPINNER_STATES)]
-                    spinner_idx += 1
-                    op_type = chunk.get("type", "search")
-                    result_count = len(chunk.get("matches", [])) if chunk.get("matches") is not None else None
-                    box_content = f"Matches so far: {result_count}" if result_count is not None else str(chunk)
-                    display_operation_box(
-                        title="Searching Filesystem" if chunk.get("progress") else "Geese Output",
-                        content=box_content,
-                        result_count=result_count,
-                        params={k: v for k, v in chunk.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done', 'spinner_state'}},
-                        progress_line=chunk.get('progress'),
-                        total_lines=chunk.get('total'),
-                        spinner_state=spinner_state,
-                        emoji="🔍" if chunk.get("progress") else "💡"
-                    )
-                else:
-                    if isinstance(chunk, dict) and 'content' in chunk:
-                        print(chunk['content'], end="")
-                    else:
-                        print(chunk, end="")
-        asyncio.run(run_and_print())
-        return
-
-    # Set DEFAULT_LLM envvar if --model is given
-    import os
-    if args.model:
-        os.environ['DEFAULT_LLM'] = args.model
-
-    async def run_and_print():
-        spinner_idx = 0
-        spinner_start = time.time()
-        from swarm.blueprints.geese.blueprint_geese import GeeseBlueprint, SPINNER_STATES, SLOW_SPINNER, display_operation_box
-        import time
-        async for chunk in blueprint.run(messages, model=args.model):
-            # If chunk is a dict with progress info, show operation box
-            if isinstance(chunk, dict) and (chunk.get("progress") or chunk.get("matches") or chunk.get("spinner_state")):
-                elapsed = time.time() - spinner_start
-                spinner_state = chunk.get("spinner_state")
-                if not spinner_state:
-                    spinner_state = SLOW_SPINNER if elapsed > 10 else SPINNER_STATES[spinner_idx % len(SPINNER_STATES)]
-                spinner_idx += 1
-                op_type = chunk.get("type", "search")
-                result_count = len(chunk.get("matches", [])) if chunk.get("matches") is not None else None
-                box_content = f"Matches so far: {result_count}" if result_count is not None else str(chunk)
-                display_operation_box(
-                    title="Searching Filesystem" if chunk.get("progress") else "Geese Output",
-                    content=box_content,
-                    result_count=result_count,
-                    params={k: v for k, v in chunk.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done', 'spinner_state'}},
-                    progress_line=chunk.get('progress'),
-                    total_lines=chunk.get('total'),
-                    spinner_state=spinner_state,
-                    emoji="🔍" if chunk.get("progress") else "💡"
-                )
-            else:
-                if isinstance(chunk, dict) and 'content' in chunk:
-                    print(chunk['content'], end="")
-                else:
-                    print(chunk, end="")
-    asyncio.run(run_and_print())
-
-if __name__ == "__main__":
-    main()

swarm/blueprints/jeeves/README.md

@@ -1,41 +0,0 @@
-# Jeeves Blueprint
-
-**Jeeves** is a multi-agent home and web orchestration blueprint for Open Swarm, demonstrating multi-agent delegation for web search and home automation, robust fallback for LLM/agent errors, and unified ANSI/emoji UX with spinner feedback.
-
----
-
-## What This Blueprint Demonstrates
-- **Multi-agent delegation and orchestration** for web search and home automation
-- **LLM fallback and error handling** with user-friendly messages
-- **Unified ANSI/emoji boxes** for operation results, including summaries, counts, and parameters
-- **Custom spinner messages**: 'Generating.', 'Generating..', 'Generating...', 'Running...'
-- **Progress updates** for long-running operations (result counts, summaries)
-- **Test mode** for robust, deterministic testing
-
-## Usage
-Run with the CLI:
-```sh
-swarm-cli run jeeves --instruction "Turn off the living room lights and search for pizza recipes."
-```
-
-## Test
-```sh
-uv run pytest -v tests/blueprints/test_jeeves.py
-```
-
-## Compliance
-- Agentic: 
-- UX (ANSI/emoji): 
-- Spinner: 
-- Fallback: 
-- Test Coverage: 
-
-## Required Env Vars
-- `SWARM_TEST_MODE` (optional): Enables test mode for deterministic output.
-
-## Extending
-- See `blueprint_jeeves.py` for agent logic and UX hooks.
-- Extend agent capabilities or UX by modifying the `_run_non_interactive` and agent orchestration methods.
-
----
-_Last updated: 2025-04-21_