open-swarm 0.1.1744937124__tar.gz → 0.1.1744942852__tar.gz

{open_swarm-0.1.1744937124 → open_swarm-0.1.1744942852}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1744937124
+Version: 0.1.1744942852
 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.1744937124 → open_swarm-0.1.1744942852}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-swarm"
-version = "0.1.1744937124"
+version = "0.1.1744942852"
 description = "Open Swarm: Orchestrating AI Agent Swarms with Django"
 readme = "README.md"
 requires-python = ">=3.10"

{open_swarm-0.1.1744937124 → open_swarm-0.1.1744942852}/src/swarm/blueprints/chatbot/blueprint_chatbot.py

@@ -1,7 +1,11 @@
+import os
+from dotenv import load_dotenv; load_dotenv(override=True)
+
 import logging
 import os
 import sys
 from typing import Dict, Any, List, ClassVar, Optional
+import argparse
 
 # Set logging to WARNING by default unless SWARM_DEBUG=1
 if not os.environ.get("SWARM_DEBUG"):
@@ -22,7 +26,7 @@ try:
     from agents.models.interface import Model
     from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
     from openai import AsyncOpenAI
-    from swarm.extensions.blueprint.blueprint_base import BlueprintBase
+    from swarm.core.blueprint_base import BlueprintBase
 except ImportError as e:
     print(f"ERROR: Import failed in ChatbotBlueprint: {e}. Check dependencies.")
     print(f"sys.path: {sys.path}")
@@ -141,8 +145,14 @@ if __name__ == "__main__":
     src_path = os.path.join(project_root, 'src')
     if src_path not in sys.path:
         sys.path.insert(0, src_path)
-    if '--instruction' in sys.argv:
-        instruction = sys.argv[sys.argv.index('--instruction') + 1]
+    parser = argparse.ArgumentParser(description='Chatbot Blueprint Runner')
+    parser.add_argument('instruction', nargs=argparse.REMAINDER, help='Instruction for Chatbot to process (all args after -- are joined as the prompt)')
+    args = parser.parse_args()
+    instruction_args = args.instruction
+    if instruction_args and instruction_args[0] == '--':
+        instruction_args = instruction_args[1:]
+    instruction = ' '.join(instruction_args).strip() if instruction_args else None
+    if instruction:
         blueprint = ChatbotBlueprint(blueprint_id="chatbot")
         async def runner():
             async for chunk in blueprint._run_non_interactive(instruction):

open_swarm-0.1.1744942852/src/swarm/blueprints/codey/blueprint_codey.py

@@ -0,0 +1,188 @@
+import os
+from dotenv import load_dotenv; load_dotenv(override=True)
+
+import logging
+from swarm.core.blueprint_base import BlueprintBase
+from agents import Agent, Tool, function_tool, Runner
+from agents.mcp import MCPServer
+from typing import List, Dict, Any, Optional, AsyncGenerator
+import sys
+import itertools
+import threading
+import time
+from rich.console import Console
+import os
+from swarm.core.blueprint_runner import BlueprintRunner
+from swarm.core.spinner import Spinner as TerminalSpinner
+
+# --- Tool Logic Definitions ---
+def git_status() -> str:
+    return "OK: git status placeholder"
+def git_diff() -> str:
+    return "OK: git diff placeholder"
+def git_add() -> str:
+    return "OK: git add placeholder"
+def git_commit(message: str) -> str:
+    return f"OK: git commit '{message}' placeholder"
+def git_push() -> str:
+    return "OK: git push placeholder"
+def run_npm_test(args: str = "") -> str:
+    return "OK: npm test placeholder"
+def run_pytest(args: str = "") -> str:
+    return "OK: pytest placeholder"
+
+git_status_tool = function_tool(git_status)
+git_diff_tool = function_tool(git_diff)
+git_add_tool = function_tool(git_add)
+git_commit_tool = function_tool(git_commit)
+git_push_tool = function_tool(git_push)
+run_npm_test_tool = function_tool(run_npm_test)
+run_pytest_tool = function_tool(run_pytest)
+
+linus_corvalds_instructions = """
+You are Linus Corvalds, the resolute leader of the Codey creative team.
+
+Respond directly and naturally to any user prompt that is creative, general, or conversational (for example, if the user asks you to write a poem, haiku, or answer a question, reply in plain language—do NOT invoke any tools or functions).
+
+Only use your available tools (git_status, git_diff, git_add, git_commit, git_push) if the user specifically requests a git/code operation, or if the request cannot be fulfilled without a tool.
+
+If you are unsure, prefer a direct response. Never output tool schema, argument names, or placeholders to the user.
+"""
+
+fiona_instructions = """
+You are Fiona Flame, the diligent git ops specialist for the Codey team.
+
+Respond directly and naturally to creative or conversational prompts. Only use your tools (git_status, git_diff, git_add, git_commit, git_push) for explicit git/code requests.
+"""
+
+sammy_instructions = """
+You are SammyScript, the test runner and automation specialist.
+
+For creative or general prompts, reply in natural language. Only use your tools (run_npm_test, run_pytest) for explicit test/code requests.
+"""
+
+# --- ANSI/Emoji Box Output Helpers ---
+def ansi_box(title, content, emoji=None, count=None, params=None):
+    box_lines = []
+    header = f"\033[1;36m┏━ {emoji+' ' if emoji else ''}{title} ━{'━'*max(0, 40-len(title))}\033[0m"
+    box_lines.append(header)
+    if params:
+        box_lines.append(f"\033[1;34m┃ Params: {params}\033[0m")
+    if count is not None:
+        box_lines.append(f"\033[1;33m┃ Results: {count}\033[0m")
+    for line in content.split('\n'):
+        box_lines.append(f"┃ {line}")
+    box_lines.append("┗"+"━"*44)
+    return "\n".join(box_lines)
+
+class CodeyBlueprint(BlueprintBase):
+    def __init__(self, blueprint_id: str, config_path: Optional[str] = None, **kwargs):
+        super().__init__(blueprint_id, config_path, **kwargs)
+        self.logger = logging.getLogger(__name__)
+        self._model_instance_cache = {}
+        self._openai_client_cache = {}
+
+    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
+        linus_corvalds = self.make_agent(
+            name="Linus_Corvalds",
+            instructions=linus_corvalds_instructions,
+            tools=[git_status_tool, git_diff_tool],
+            mcp_servers=mcp_servers
+        )
+        fiona_flame = self.make_agent(
+            name="Fiona_Flame",
+            instructions=fiona_instructions,
+            tools=[git_status_tool, git_diff_tool, git_add_tool, git_commit_tool, git_push_tool],
+            mcp_servers=mcp_servers
+        )
+        sammy_script = self.make_agent(
+            name="SammyScript",
+            instructions=sammy_instructions,
+            tools=[run_npm_test_tool, run_pytest_tool],
+            mcp_servers=mcp_servers
+        )
+        linus_corvalds.tools.append(fiona_flame.as_tool(tool_name="Fiona_Flame", tool_description="Delegate git actions to Fiona."))
+        linus_corvalds.tools.append(sammy_script.as_tool(tool_name="SammyScript", tool_description="Delegate testing tasks to Sammy."))
+        return linus_corvalds
+
+    async def run(self, messages: List[dict], **kwargs):
+        self.logger.info("CodeyBlueprint run method called.")
+        instruction = messages[-1].get("content", "") if messages else ""
+        try:
+            mcp_servers = kwargs.get("mcp_servers", [])
+            starting_agent = self.create_starting_agent(mcp_servers=mcp_servers)
+            model_name = os.getenv("LITELLM_MODEL") or os.getenv("DEFAULT_LLM") or "gpt-3.5-turbo"
+            if not starting_agent.model:
+                yield {"messages": [{"role": "assistant", "content": f"Error: No model instance available for Codey agent. Check your LITELLM_MODEL, OPENAI_API_KEY, or DEFAULT_LLM config."}]}
+                return
+            if not starting_agent.tools:
+                yield {"messages": [{"role": "assistant", "content": f"Warning: No tools registered for Codey agent. Only direct LLM output is possible."}]}
+            required_mcps = []
+            if hasattr(self, 'metadata') and self.metadata.get('required_mcp_servers'):
+                required_mcps = self.metadata['required_mcp_servers']
+                missing_mcps = [m for m in required_mcps if m not in [s.name for s in mcp_servers]]
+                if missing_mcps:
+                    yield {"messages": [{"role": "assistant", "content": f"Warning: Missing required MCP servers: {', '.join(missing_mcps)}. Some features may not work."}]}
+            show_intermediate = kwargs.get("show_intermediate", False)
+            spinner = None
+            if show_intermediate:
+                spinner = TerminalSpinner(interactive=True, custom_sequence="generating")
+                spinner.start()
+            try:
+                async for chunk in BlueprintRunner.run_agent(starting_agent, instruction):
+                    if show_intermediate:
+                        for msg in chunk["messages"]:
+                            print(msg["content"])
+                    yield chunk
+            finally:
+                if spinner:
+                    spinner.stop()
+        except Exception as e:
+            yield {"messages": [{"role": "assistant", "content": f"Error: {e}"}]}
+
+if __name__ == "__main__":
+    import argparse
+    import asyncio
+    parser = argparse.ArgumentParser(description="Run the Codey blueprint.")
+    parser.add_argument('instruction', nargs=argparse.REMAINDER, help='Instruction for Codey to process (all args after -- are joined as the prompt)')
+    parser.add_argument('--show-intermediate', action='store_true', help='Show all intermediate outputs (verbose mode)')
+    args = parser.parse_args()
+    # Join all positional arguments as the instruction
+    instruction_args = args.instruction
+    if instruction_args and instruction_args[0] == '--':
+        instruction_args = instruction_args[1:]
+    instruction = ' '.join(instruction_args).strip() if instruction_args else None
+    show_intermediate = args.show_intermediate
+    blueprint = CodeyBlueprint(blueprint_id="codey")
+    if instruction:
+        # Non-interactive mode: run once and exit
+        async def main():
+            messages = [{"role": "user", "content": instruction}]
+            last_assistant_msg = None
+            async for resp in blueprint.run(messages, show_intermediate=show_intermediate):
+                for msg in resp["messages"]:
+                    if show_intermediate:
+                        print(msg["content"])
+                    elif msg["role"] == "assistant":
+                        last_assistant_msg = msg["content"]
+            if not show_intermediate and last_assistant_msg is not None:
+                print(last_assistant_msg)
+        asyncio.run(main())
+    else:
+        # Interactive mode: loop and accept follow-ups
+        async def interactive_loop():
+            messages = []
+            while True:
+                try:
+                    user_input = input("User: ").strip()
+                except EOFError:
+                    print("Exiting interactive mode.")
+                    break
+                if not user_input:
+                    print("No input. Exiting.")
+                    break
+                messages.append({"role": "user", "content": user_input})
+                async for resp in blueprint.run(messages):
+                    for msg in resp["messages"]:
+                        print(msg["content"])
+        asyncio.run(interactive_loop())

{open_swarm-0.1.1744937124 → open_swarm-0.1.1744942852}/src/swarm/blueprints/gaggle/blueprint_gaggle.py

@@ -1,6 +1,8 @@
+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 os
 import sys
 
 # --- Universal Logging Reset ---
@@ -36,8 +38,7 @@ try:
     from agents.models.interface import Model
     from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
     from openai import AsyncOpenAI
-    # Corrected Import: Relative path within the package
-    from swarm.extensions.blueprint.blueprint_base import BlueprintBase
+    from swarm.core.blueprint_base import BlueprintBase
 except ImportError as e:
     print(f"ERROR: Import failed in blueprint_gaggle: {e}. Check 'openai-agents' install and project structure.")
     print(f"sys.path: {sys.path}")
@@ -283,4 +284,20 @@ class GaggleBlueprint(BlueprintBase):
 
 
 if __name__ == "__main__":
-    GaggleBlueprint.main()
+    parser = argparse.ArgumentParser(description='Gaggle Story Writing Team')
+    parser.add_argument('instruction', nargs=argparse.REMAINDER, help='Instruction for Gaggle to process (all args after -- are joined as the prompt)')
+    args = parser.parse_args()
+    instruction_args = args.instruction
+    if instruction_args and instruction_args[0] == '--':
+        instruction_args = instruction_args[1:]
+    instruction = ' '.join(instruction_args).strip() if instruction_args else None
+    blueprint = GaggleBlueprint('gaggle')
+    import asyncio
+    if instruction:
+        async def main():
+            async for chunk in blueprint._run_non_interactive(instruction):
+                print(chunk)
+        asyncio.run(main())
+    else:
+        blueprint.display_splash_screen()
+        blueprint.run_interactive()

{open_swarm-0.1.1744937124 → open_swarm-0.1.1744942852}/src/swarm/blueprints/whiskeytango_foxtrot/blueprint_whiskeytango_foxtrot.py

@@ -5,9 +5,11 @@ A chaotic spy-themed blueprint with a multi-tiered agent hierarchy for tracking
 Uses BlueprintBase and agent-as-tool delegation.
 """
 
+import os
+from dotenv import load_dotenv; load_dotenv(override=True)
+
 import logging
 import sqlite3
-import os
 import sys
 from pathlib import Path
 from typing import Dict, Any, List, ClassVar, Optional
@@ -23,7 +25,7 @@ try:
     from agents.models.interface import Model
     from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
     from openai import AsyncOpenAI
-    from swarm.extensions.blueprint.blueprint_base import BlueprintBase
+    from swarm.core.blueprint_base import BlueprintBase
 except ImportError as e:
     print(f"ERROR: Import failed in WhiskeyTangoFoxtrotBlueprint: {e}. Check dependencies.")
     print(f"sys.path: {sys.path}")
@@ -192,6 +194,35 @@ class WhiskeyTangoFoxtrotBlueprint(BlueprintBase):
         except Exception as e: raise ValueError(f"Failed to init LLM: {e}") from e
 
 
+    async def run(self, messages: List[dict], **kwargs):
+        logger.info("WhiskeyTangoFoxtrotBlueprint run method called.")
+        instruction = messages[-1].get("content", "") if messages else ""
+        try:
+            mcp_servers = kwargs.get("mcp_servers", [])
+            starting_agent = self.create_starting_agent(mcp_servers=mcp_servers)
+            from agents import Runner
+            if not starting_agent.model:
+                yield {"messages": [{"role": "assistant", "content": f"Error: No model instance available for WTF agent. Check your OPENAI_API_KEY, or LITELLM_MODEL/LITELLM_BASE_URL config."}]}
+                return
+            if not starting_agent.tools:
+                yield {"messages": [{"role": "assistant", "content": f"Warning: No tools registered for WTF agent. Only direct LLM output is possible."}]}
+            required_mcps = self.metadata.get('required_mcp_servers', [])
+            missing_mcps = [m for m in required_mcps if m not in [s.name for s in mcp_servers]]
+            if missing_mcps:
+                yield {"messages": [{"role": "assistant", "content": f"Warning: Missing required MCP servers: {', '.join(missing_mcps)}. Some features may not work."}]}
+            from rich.console import Console
+            console = Console()
+            with console.status("Generating...", spinner="dots") as status:
+                async for chunk in Runner.run(starting_agent, instruction):
+                    content = chunk.get("content")
+                    if content and ("function call" in content or "args" in content):
+                        continue
+                    yield chunk
+            logger.info("WhiskeyTangoFoxtrotBlueprint run method finished.")
+        except Exception as e:
+            yield {"messages": [{"role": "assistant", "content": f"Error: {e}"}]}
+
+
     def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
         """Creates the WTF agent hierarchy and returns Valory (Coordinator)."""
         self.initialize_db() # Ensure DB is ready
@@ -253,4 +284,3 @@ class WhiskeyTangoFoxtrotBlueprint(BlueprintBase):
 # Standard Python entry point
 if __name__ == "__main__":
     WhiskeyTangoFoxtrotBlueprint.main()
-

{open_swarm-0.1.1744937124 → open_swarm-0.1.1744942852}/src/swarm/extensions/blueprint/__init__.py

@@ -6,7 +6,7 @@ and running autonomous agent workflows (blueprints).
 """
 
 # Core components
-from .blueprint_base import BlueprintBase
+from swarm.core.blueprint_base import BlueprintBase
 from .blueprint_discovery import discover_blueprints
 from .blueprint_utils import filter_blueprints
 
@@ -48,4 +48,3 @@ __all__ = [
     "validate_message_sequence",
     "truncate_message_history",
 ]
-

{open_swarm-0.1.1744937124 → open_swarm-0.1.1744942852}/src/swarm/extensions/blueprint/cli_handler.py

@@ -24,6 +24,7 @@ logger = logging.getLogger("swarm.cli")
 project_root = Path(__file__).parent.parent.parent.parent  # /home/chatgpt/open-swarm
 dotenv_path = project_root / ".env"
 load_dotenv(dotenv_path=dotenv_path, override=True)
+print("[DEBUG] LITELLM_API_KEY:", os.environ.get("LITELLM_API_KEY"))
 # print(f"[DEBUG] Loaded .env from: {dotenv_path}")
 # print(f"[DEBUG] LITELLM_MODEL={os.environ.get('LITELLM_MODEL')}")
 # print(f"[DEBUG] LITELLM_BASE_URL={os.environ.get('LITELLM_BASE_URL')}")
@@ -54,10 +55,12 @@ async def _run_blueprint_async_with_shutdown(blueprint: 'BlueprintBase', instruc
             except Exception as e:
                  logger.error(f"Unexpected error setting fallback signal handler for {sig.name}: {e}", exc_info=True)
 
-
     # Instead of wrapping in a task and awaiting, use async for to support async generators
     try:
-        async for chunk in blueprint._run_non_interactive(instruction):
+        # PATCH: Use blueprint.run instead of blueprint._run_non_interactive
+        async for chunk in blueprint.run([
+            {"role": "user", "content": instruction}
+        ]):
             # Print the full JSON chunk
             print(json.dumps(chunk, ensure_ascii=False))
             # If chunk contains 'messages', print each assistant message's content for CLI/test UX
@@ -90,7 +93,6 @@ def run_blueprint_cli(
         description=metadata.get("description", f"Run {blueprint_cls.__name__}"),
         formatter_class=argparse.RawTextHelpFormatter
     )
-    parser.add_argument("--instruction", type=str, required=True, help="Initial instruction for the blueprint.")
     parser.add_argument("--config-path", type=str, default=None, help=f"Path to swarm_config.json (Default: {default_config_path})")
     parser.add_argument("--config", type=str, metavar="JSON_FILE_OR_STRING", default=None, help="JSON config overrides (file path or string). Merged last.")
     parser.add_argument("--profile", type=str, default=None, help="Configuration profile to use.")
@@ -98,8 +100,22 @@ def run_blueprint_cli(
     parser.add_argument("--quiet", action="store_true", help="Suppress most logs and headers, print only final output.")
     parser.add_argument('--markdown', action=argparse.BooleanOptionalAction, default=None, help="Enable/disable markdown output (--markdown / --no-markdown). Overrides config/default.")
     parser.add_argument("--version", action="version", version=f"%(prog)s (BP: {metadata.get('name', 'N/A')} v{metadata.get('version', 'N/A')}, Core: {swarm_version})")
+    parser.add_argument("instruction", nargs=argparse.REMAINDER, help="Instruction or prompt for the blueprint. All arguments after -- are treated as the prompt.")
     args = parser.parse_args()
 
+    # Determine instruction string: if '--' is present, treat everything after as prompt
+    instruction_args = args.instruction
+    if instruction_args:
+        # Remove leading '--' if present
+        if instruction_args and instruction_args[0] == '--':
+            instruction_args = instruction_args[1:]
+        instruction = ' '.join(instruction_args).strip()
+    else:
+        instruction = ''
+
+    if not instruction:
+        parser.error("No instruction provided. Pass a prompt after -- or as positional arguments.")
+
     # --- Load CLI Config Overrides ---
     cli_config_overrides = {}
     if args.config:
@@ -142,7 +158,7 @@ def run_blueprint_cli(
         )
 
         # Run the async part with shutdown handling
-        asyncio.run(_run_blueprint_async_with_shutdown(blueprint_instance, args.instruction))
+        asyncio.run(_run_blueprint_async_with_shutdown(blueprint_instance, instruction))
 
     except (ValueError, TypeError, FileNotFoundError) as config_err:
         logger.critical(f"[Initialization Error] Configuration problem: {config_err}", exc_info=args.debug)

open_swarm-0.1.1744937124/src/swarm/extensions/blueprint/agent_utils.py

@@ -1,21 +0,0 @@
-"""
-agent_utils.py
-
-Utility functions for agent operations used in blueprints.
-This module has been updated to remove dependency on swarm.types;
-instead, it now imports Agent from the openai-agents SDK.
-"""
-
-from blueprint_agents.agent import Agent  # Updated import
-
-def get_agent_name(agent: Agent) -> str:
-    """
-    Returns the name of the agent.
-    """
-    return agent.name
-
-def initialize_agents(blueprint) -> dict:
-    """
-    Initializes agents by calling the blueprint's create_agents() method.
-    """
-    return blueprint.create_agents()