open-swarm 0.1.1744936173__py3-none-any.whl → 0.1.1744936297__py3-none-any.whl

swarm/extensions/blueprint/spinner.py

@@ -6,29 +6,36 @@ import os
 import sys
 import threading
 import time
+from typing import Optional
 
 class Spinner:
     """Simple terminal spinner for interactive feedback."""
     # Define spinner characters (can be customized)
     SPINNER_CHARS = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-    # SPINNER_CHARS = ['|', '/', '-', '\\'] # Simpler alternative
+    # Custom status sequences for special cases
+    STATUS_SEQUENCES = {
+        'generating': ['Generating.', 'Generating..', 'Generating...'],
+        'running': ['Running...']
+    }
 
-    def __init__(self, interactive: bool):
+    def __init__(self, interactive: bool, custom_sequence: str = None):
         """
         Initialize the spinner.
 
         Args:
             interactive (bool): Hint whether the environment is interactive.
                                 Spinner is disabled if False or if output is not a TTY.
+            custom_sequence (str): Optional name for a custom status sequence (e.g., 'generating', 'running').
         """
         self.interactive = interactive
-        # Check if output is a TTY (terminal) and interactive flag is True
         self.is_tty = sys.stdout.isatty()
         self.enabled = self.interactive and self.is_tty
         self.running = False
         self.thread: Optional[threading.Thread] = None
         self.status = ""
         self.index = 0
+        self.custom_sequence = custom_sequence
+        self.sequence_idx = 0
 
     def start(self, status: str = "Processing..."):
         """Start the spinner with an optional status message."""
@@ -36,7 +43,7 @@ class Spinner:
             return # Do nothing if disabled or already running
         self.status = status
         self.running = True
-        # Run the spinner animation in a separate daemon thread
+        self.sequence_idx = 0
         self.thread = threading.Thread(target=self._spin, daemon=True)
         self.thread.start()
 
@@ -47,30 +54,33 @@ class Spinner:
         self.running = False
         if self.thread is not None:
             self.thread.join() # Wait for the thread to finish
-        # Clear the spinner line using ANSI escape codes
-        # \r: Carriage return (move cursor to beginning of line)
-        # \033[K: Clear line from cursor to end
         sys.stdout.write("\r\033[K")
         sys.stdout.flush()
-        self.thread = None # Reset thread
+        self.thread = None
 
     def _spin(self):
         """Internal method running in the spinner thread to animate."""
+        start_time = time.time()
+        warned = False
         while self.running:
-            # Get the next spinner character
-            char = self.SPINNER_CHARS[self.index % len(self.SPINNER_CHARS)]
-            # Write spinner char and status, overwrite previous line content
-            try:
-                # \r moves cursor to beginning, \033[K clears the rest of the line
+            elapsed = time.time() - start_time
+            if self.custom_sequence and self.custom_sequence in self.STATUS_SEQUENCES:
+                seq = self.STATUS_SEQUENCES[self.custom_sequence]
+                # If taking longer than 10s, show special message
+                if elapsed > 10 and not warned:
+                    msg = f"{seq[-1]} Taking longer than expected"
+                    warned = True
+                else:
+                    msg = seq[self.sequence_idx % len(seq)]
+                sys.stdout.write(f"\r{msg}\033[K")
+                sys.stdout.flush()
+                self.sequence_idx += 1
+            else:
+                char = self.SPINNER_CHARS[self.index % len(self.SPINNER_CHARS)]
                 sys.stdout.write(f"\r{char} {self.status}\033[K")
                 sys.stdout.flush()
-            except BlockingIOError:
-                 # Handle potential issues if stdout is blocked (less likely for TTY)
-                 time.sleep(0.1)
-                 continue
-            self.index += 1
-            # Pause for animation effect
-            time.sleep(0.1)
+                self.index += 1
+            time.sleep(0.4 if self.custom_sequence else 0.1)
 
 # Example usage (if run directly)
 if __name__ == "__main__":
@@ -88,4 +98,3 @@ if __name__ == "__main__":
     finally:
         s.stop() # Ensure spinner stops on exit/error
         print("Test finished.")
-

swarm/extensions/cli/cli_args.py

@@ -1,8 +1,14 @@
 # src/swarm/extensions/blueprint/modes/cli_mode/cli_args.py
 
 import argparse
+import os
+import sys
 from typing import Namespace
 
+# --- DEBUG PRINTS REMOVED BY CASCADE ---
+# print(f"[DEBUG] cli_args.py startup: sys.argv={sys.argv}")
+# print(f"[DEBUG] cli_args.py startup: LITELLM_MODEL={os.environ.get('LITELLM_MODEL')}, DEFAULT_LLM={os.environ.get('DEFAULT_LLM')}")
+
 def parse_arguments() -> Namespace:
     """
     Parse command-line arguments for dynamic LLM configuration, MCP server management, and other overrides.

swarm/extensions/config/config_loader.py

@@ -57,6 +57,10 @@ def _substitute_env_vars_recursive(data: Any) -> Any:
     if isinstance(data,str): return os.path.expandvars(data)
     return data
 
+def _substitute_env_vars(data: Any) -> Any:
+    """Public API: Recursively substitute environment variables in dict, list, str."""
+    return _substitute_env_vars_recursive(data)
+
 def create_default_config(config_path: Path):
     """Creates a default configuration file with valid JSON."""
     default_config = {
@@ -88,4 +92,3 @@ def create_default_config(config_path: Path):
     except Exception as e:
         logger.error(f"Failed to create default config file at {config_path}: {e}", exc_info=True)
         raise
-

swarm/llm/chat_completion.py

@@ -18,7 +18,6 @@ from ..utils.redact import redact_sensitive_data
 from ..utils.general_utils import serialize_datetime
 from ..utils.message_utils import filter_duplicate_system_messages, update_null_content
 from ..utils.context_utils import get_token_count, truncate_message_history
-# --- REMOVED import: from ..utils.message_sequence import repair_message_payload ---
 
 # Configure module-level logging
 logger = logging.getLogger(__name__)
@@ -29,6 +28,29 @@ if not logger.handlers:
     stream_handler.setFormatter(formatter)
     logger.addHandler(stream_handler)
 
+# --- PATCH: Suppress OpenAI tracing/telemetry errors if using LiteLLM/custom endpoint ---
+import logging
+import os
+if os.environ.get("LITELLM_BASE_URL") or os.environ.get("OPENAI_BASE_URL"):
+    # Silence openai.agents tracing/telemetry errors
+    logging.getLogger("openai.agents").setLevel(logging.CRITICAL)
+    try:
+        import openai.agents.tracing
+        openai.agents.tracing.TracingClient = lambda *a, **kw: None
+    except Exception:
+        pass
+
+# --- PATCH: Enforce custom endpoint, never fallback to OpenAI if custom base_url is set ---
+def _enforce_litellm_only(client):
+    # If client has a base_url attribute, check it
+    base_url = getattr(client, 'base_url', None)
+    if base_url and 'openai.com' in base_url:
+        return  # Using OpenAI, allowed
+    if base_url and 'openai.com' not in base_url:
+        # If any fallback to OpenAI API is attempted, raise error
+        import traceback
+        raise RuntimeError(f"Attempted fallback to OpenAI API when custom base_url is set! base_url={base_url}\n{traceback.format_stack()}")
+
 
 async def get_chat_completion(
     client: AsyncOpenAI,
@@ -44,6 +66,7 @@ async def get_chat_completion(
     stream: bool = False,
     debug: bool = False
 ) -> Union[Dict[str, Any], AsyncGenerator[Any, None]]:
+    _enforce_litellm_only(client)
     """
     Retrieve a chat completion from the LLM for the given agent and history.
     Relies on openai-agents Runner for actual execution, this might become deprecated.
@@ -62,6 +85,12 @@ async def get_chat_completion(
     redacted_kwargs = redact_sensitive_data(client_kwargs, sensitive_keys=["api_key"])
     logger.debug(f"Using client with model='{active_model}', base_url='{client_kwargs.get('base_url', 'default')}', api_key={redacted_kwargs['api_key']}")
 
+    # --- ENFORCE: Disallow fallback to OpenAI if custom base_url is set ---
+    if client_kwargs.get("base_url") and "openai.com" not in client_kwargs["base_url"]:
+        # If the base_url is set and is not OpenAI, ensure no fallback to OpenAI API
+        if "openai.com" in os.environ.get("OPENAI_API_BASE", ""):
+            raise RuntimeError(f"[SECURITY] Fallback to OpenAI API attempted with base_url={client_kwargs['base_url']}. Refusing for safety.")
+
     context_variables = defaultdict(str, context_variables)
     instructions = agent.instructions(context_variables) if callable(agent.instructions) else agent.instructions
     if not isinstance(instructions, str):
@@ -152,6 +181,7 @@ async def get_chat_completion_message(
     stream: bool = False,
     debug: bool = False
 ) -> Union[Dict[str, Any], AsyncGenerator[Any, None]]:
+    _enforce_litellm_only(client)
     """
     Wrapper to retrieve and validate a chat completion message (returns dict or stream).
     Relies on openai-agents Runner for actual execution, this might become deprecated.

swarm/settings.py

@@ -12,7 +12,7 @@ BASE_DIR = Path(__file__).resolve().parent.parent # Points to src/
 # --- Load .env file ---
 dotenv_path = BASE_DIR.parent / '.env'
 load_dotenv(dotenv_path=dotenv_path)
-print(f"[Settings] Attempted to load .env from: {dotenv_path}")
+# print(f"[Settings] Attempted to load .env from: {dotenv_path}")
 # ---
 
 SECRET_KEY = os.getenv('DJANGO_SECRET_KEY', 'django-insecure-fallback-key-for-dev')
@@ -30,12 +30,12 @@ SWARM_API_KEY = _raw_api_token # Assign the loaded token (or None)
 if ENABLE_API_AUTH:
     # Add assertion to satisfy type checkers within this block
     assert SWARM_API_KEY is not None, "SWARM_API_KEY cannot be None when ENABLE_API_AUTH is True"
-    print(f"[Settings] SWARM_API_KEY loaded: {SWARM_API_KEY[:4]}...{SWARM_API_KEY[-4:]}")
-    print("[Settings] ENABLE_API_AUTH is True.")
+    # print(f"[Settings] SWARM_API_KEY loaded: {SWARM_API_KEY[:4]}...{SWARM_API_KEY[-4:]}")
+    # print("[Settings] ENABLE_API_AUTH is True.")
 else:
-    print("[Settings] API_AUTH_TOKEN env var not set. SWARM_API_KEY is None.")
-    print("[Settings] ENABLE_API_AUTH is False.")
-
+    # print("[Settings] API_AUTH_TOKEN env var not set. SWARM_API_KEY is None.")
+    # print("[Settings] ENABLE_API_AUTH is False.")
+    pass
 
 SWARM_CONFIG_PATH = os.getenv('SWARM_CONFIG_PATH', str(BASE_DIR.parent / 'swarm_config.json'))
 BLUEPRINT_DIRECTORY = os.getenv('BLUEPRINT_DIRECTORY', str(BASE_DIR / 'swarm' / 'blueprints'))
@@ -175,4 +175,3 @@ LOGIN_URL = '/login/'
 LOGIN_REDIRECT_URL = '/'
 LOGOUT_REDIRECT_URL = '/'
 CSRF_TRUSTED_ORIGINS = os.getenv('DJANGO_CSRF_TRUSTED_ORIGINS', 'http://localhost:8000,http://127.0.0.1:8000').split(',')
-