open-swarm 0.1.1745125813__tar.gz → 0.1.1745125879__tar.gz

{open_swarm-0.1.1745125813 → open_swarm-0.1.1745125879}/PKG-INFO

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

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

open_swarm-0.1.1745125879/src/swarm/utils/disable_tracing.py

@@ -0,0 +1,38 @@
+"""
+Utility to disable OpenAI Agents Python tracing by default unless explicitly enabled in config.
+"""
+import os
+import json
+
+def traces_enabled_from_config(config_path="swarm_config.json"):
+    try:
+        with open(config_path) as f:
+            config = json.load(f)
+        # Look for openai_traces or similar in LLM config
+        llm_config = config.get("llm", {})
+        return llm_config.get("openai_traces", False)
+    except Exception:
+        return False
+
+def disable_openai_agents_tracing():
+    try:
+        import agents.tracing.create as tracing_create
+        import agents.tracing.setup as tracing_setup
+        # Patch GLOBAL_TRACE_PROVIDER to always return disabled traces
+        class DisabledTrace:
+            def __init__(self, *a, **k): pass
+            def __enter__(self): return self
+            def __exit__(self, *a, **k): pass
+            def start(self): return self
+            def finish(self): return self
+        class DummyProvider:
+            def get_current_trace(self): return DisabledTrace()
+            def new_trace(self, *a, **k): return DisabledTrace()
+        tracing_setup.GLOBAL_TRACE_PROVIDER = DummyProvider()
+        tracing_create.trace = lambda *a, **k: DisabledTrace()
+    except ImportError:
+        pass
+
+# At import, check config and disable tracing if not enabled
+if not traces_enabled_from_config():
+    disable_openai_agents_tracing()

{open_swarm-0.1.1745125813 → open_swarm-0.1.1745125879}/src/swarm/utils/general_utils.py

@@ -118,6 +118,27 @@ def _search_and_process_jmespath(expression: str, payload: dict) -> str:
 
     return str(chat_id) if chat_id is not None else ""
 
+# ---------------------------------------------------------------------------
+# Debug utilities
+# ---------------------------------------------------------------------------
+
+_DEBUG_ENV_VARS = ("SWARM_DEBUG", "DEBUG", "OPEN_SWARM_DEBUG")
+
+
+def is_debug_enabled() -> bool:
+    """Return True if any recognised debug environment variable is truthy.
+
+    A value is considered *truthy* when it is set and **not** one of
+    "0", "false", "off" (case‑insensitive).
+    """
+    import os
+
+    for var in _DEBUG_ENV_VARS:
+        val = os.getenv(var)
+        if val and val.lower() not in ("0", "false", "off"):
+            return True
+    return False
+
 
 def extract_chat_id(payload: dict) -> str:
     """

open_swarm-0.1.1745125879/src/swarm/utils/openai_patch.py

@@ -0,0 +1,33 @@
+"""
+Monkeypatch OpenAI SDK to prevent telemetry/tracing when using a custom endpoint.
+This disables any calls to OpenAI's internal tracing/telemetry/reporting subsystems.
+Should be imported at startup if a custom OpenAI endpoint is used.
+"""
+
+def patch_openai_telemetry():
+    try:
+        import openai
+        # Patch telemetry/tracing if present (for openai>=1.0.0)
+        # For openai<1.0.0, there is no tracing, but be defensive.
+        if hasattr(openai, "_telemetry"):
+            openai._telemetry = None
+        # For openai>=1.0.0, tracing is in openai.tracing
+        if hasattr(openai, "tracing"):
+            class DummyTracer:
+                def add_event(self, *a, **k): pass
+                def post(self, *a, **k): pass
+                def record(self, *a, **k): pass
+            openai.tracing.tracer = DummyTracer()
+        # Patch any post/trace/report methods
+        for attr in ("post", "trace", "report", "send_usage", "_post"):
+            if hasattr(openai, attr):
+                setattr(openai, attr, lambda *a, **k: None)
+        # Patch environment variable if supported
+        import os
+        os.environ["OPENAI_TELEMETRY_OPTS"] = "off"
+    except ImportError:
+        pass
+
+# Optionally, auto-patch if this file is imported as __main__
+if __name__ == "__main__":
+    patch_openai_telemetry()

open_swarm-0.1.1745125879/src/swarm/utils/redact.py

@@ -0,0 +1,55 @@
+"""
+Utilities for redacting sensitive data.
+"""
+
+import re
+from typing import Union, Dict, List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SENSITIVE_KEYS = ["secret", "password", "api_key", "apikey", "token", "access_token", "client_secret"]
+
+def redact_sensitive_data(
+    data: Union[str, Dict, List],
+    sensitive_keys: Optional[List[str]] = None,
+    reveal_chars: int = 0,
+    mask: str = "[REDACTED]"
+) -> Union[str, Dict, List]:
+    """
+    Recursively redact sensitive information from dictionaries or lists based on keys.
+    By default, fully masks sensitive values (returns only the mask).
+    If reveal_chars > 0, partially masks (preserves reveal_chars at start/end).
+    If a custom mask is provided, always use it (for test compatibility).
+    Does NOT redact standalone strings.
+    """
+    keys_to_redact = set((k.lower() for k in (sensitive_keys or DEFAULT_SENSITIVE_KEYS)))
+    def smart_mask(val: str) -> str:
+        if not isinstance(val, str):
+            return val
+        if mask != "[REDACTED]":
+            return mask
+        if reveal_chars == 0:
+            return mask
+        if len(val) >= 2 * reveal_chars + 1:
+            return val[:reveal_chars] + mask + val[-reveal_chars:]
+        return mask
+    if isinstance(data, dict):
+        redacted_dict = {}
+        for k, v in data.items():
+            if isinstance(k, str) and k.lower() in keys_to_redact:
+                redacted_dict[k] = smart_mask(v)
+            elif isinstance(v, (dict, list)):
+                redacted_dict[k] = redact_sensitive_data(v, sensitive_keys, reveal_chars, mask)
+            else:
+                redacted_dict[k] = v
+        return redacted_dict
+    elif isinstance(data, list):
+        processed_list = []
+        for item in data:
+            if isinstance(item, (dict, list)):
+                processed_list.append(redact_sensitive_data(item, sensitive_keys, reveal_chars, mask))
+            else:
+                processed_list.append(item)
+        return processed_list
+    return data

open_swarm-0.1.1745125813/src/swarm/utils/redact.py

@@ -1,68 +0,0 @@
-"""
-Utilities for redacting sensitive data.
-"""
-
-import re
-from typing import Union, Dict, List, Optional
-import logging
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_SENSITIVE_KEYS = ["secret", "password", "api_key", "apikey", "token", "access_token", "client_secret"]
-
-def redact_sensitive_data(
-    data: Union[str, Dict, List],
-    sensitive_keys: Optional[List[str]] = None,
-    reveal_chars: int = 4,
-    mask: str = "[REDACTED]"
-) -> Union[str, Dict, List]:
-    """
-    Recursively redact sensitive information from dictionaries or lists based on keys.
-    Applies partial redaction to string values associated with sensitive keys.
-    Does NOT redact standalone strings.
-
-    Args:
-        data: Input data to redact (dict or list). Other types returned as is.
-        sensitive_keys: List of dictionary keys to treat as sensitive. Defaults to common keys.
-        reveal_chars: Number of initial/trailing characters to reveal (0 means full redaction).
-        mask: String used for redaction in the middle or for full redaction of strings.
-
-    Returns:
-        Redacted data structure of the same type as input.
-    """
-    keys_to_redact = sensitive_keys if sensitive_keys is not None else DEFAULT_SENSITIVE_KEYS
-    keys_to_redact_lower = {key.lower() for key in keys_to_redact}
-
-    if isinstance(data, dict):
-        redacted_dict = {}
-        for key, value in data.items():
-            if isinstance(key, str) and key.lower() in keys_to_redact_lower:
-                if isinstance(value, str):
-                    val_len = len(value)
-                    if reveal_chars > 0 and val_len > reveal_chars * 2:
-                        redacted_dict[key] = f"{value[:reveal_chars]}{mask}{value[-reveal_chars:]}"
-                    elif val_len > 0:
-                         # Use the provided mask string directly for full redaction
-                         redacted_dict[key] = mask
-                    else:
-                         redacted_dict[key] = "" # Redact empty string as empty
-                else:
-                    # Use specific placeholder for non-strings
-                    redacted_dict[key] = "[REDACTED NON-STRING]"
-            else:
-                # Recursively redact nested structures if key is not sensitive
-                redacted_dict[key] = redact_sensitive_data(value, keys_to_redact, reveal_chars, mask)
-        return redacted_dict
-
-    elif isinstance(data, list):
-        # Recursively redact items in a list ONLY if they are dicts or lists themselves.
-        processed_list = []
-        for item in data:
-            if isinstance(item, (dict, list)):
-                processed_list.append(redact_sensitive_data(item, keys_to_redact, reveal_chars, mask))
-            else:
-                processed_list.append(item) # Keep non-dict/list items (like strings) unchanged
-        return processed_list
-
-    # Return data unchanged if it's not a dict or list (including standalone strings)
-    return data