open-swarm 0.1.1743371228__py3-none-any.whl → 0.1.1743372974__py3-none-any.whl

{open_swarm-0.1.1743371228.dist-info → open_swarm-0.1.1743372974.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1743371228
+Version: 0.1.1743372974
 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
@@ -104,7 +104,7 @@ Open Swarm can be used in two primary ways:
 
 *   **Agents:** Individual AI units performing specific tasks, powered by LLMs (like GPT-4, Claude, etc.). Built using the `openai-agents` SDK.
 *   **Blueprints:** Python classes (`BlueprintBase` subclasses) defining a swarm's structure, agents, coordination logic, and external dependencies (like required environment variables or MCP servers). They act as reusable templates for specific tasks (e.g., code generation, research, data analysis).
-*   **MCP (Mission Control Platform) Servers:** Optional external processes providing specialized capabilities (tools) to agents, such as filesystem access, web browsing, database interaction, or interacting with specific APIs (Slack, Monday.com, etc.). Agents interact with MCP servers via a standardized communication protocol.
+*   **MCP (Model Context Protocol) Servers:** Optional external processes providing specialized capabilities (tools) to agents, such as filesystem access, web browsing, database interaction, or interacting with specific APIs (Slack, Monday.com, etc.). Agents interact with MCP servers via a standardized communication protocol.
 *   **Configuration (`swarm_config.json`):** A central JSON file defining available LLM profiles (API keys, models) and configurations for MCP servers. Typically managed via `swarm-cli` in `~/.config/swarm/`.
 *   **`swarm-cli`:** A command-line tool for managing blueprints (adding, listing, running, installing) and the `swarm_config.json` file. Uses XDG directories for storing blueprints (`~/.local/share/swarm/blueprints/`) and configuration (`~/.config/swarm/`).
 *   **`swarm-api`:** A launcher for the Django/DRF backend that exposes installed blueprints via an OpenAI-compatible REST API (`/v1/models`, `/v1/chat/completions`).

{open_swarm-0.1.1743371228.dist-info → open_swarm-0.1.1743372974.dist-info}/RECORD

@@ -26,7 +26,7 @@ swarm/blueprints/django_chat/blueprint_django_chat.py,sha256=jROcPgqNJZv2E2efCoG
 swarm/blueprints/django_chat/urls.py,sha256=TTTF3pgymvCYbuxpwi4WRBPv8ftQNH4pEoURT8sEVAg,147
 swarm/blueprints/django_chat/views.py,sha256=MUKjXXjXsq8jMZtAb4RR9g2mEYrwFemN6Bqxpeyi7p4,1299
 swarm/blueprints/django_chat/templates/django_chat/django_chat_webpage.html,sha256=wAEOI4Wg0JJ8drXaOcr2Pel6lW3JSHmyIpbocLS5tI8,1649
-swarm/blueprints/echocraft/blueprint_echocraft.py,sha256=kd5EFDhveaF2oaaYXhycakA9TYyH7KuXluyb99V4Puo,1589
+swarm/blueprints/echocraft/blueprint_echocraft.py,sha256=6xQT9qb2mIf28TAj1N4lWN1PzTq4CWVmPeTG_3Flrpc,2740
 swarm/blueprints/family_ties/apps.py,sha256=EjV7AxDNsLM4gsLr_qMEiLAVbERuo1ZsdU9vPtOEYAY,287
 swarm/blueprints/family_ties/blueprint_family_ties.py,sha256=XVcSZNHmqQNqyjDZM36wtUh2V2Qx2_lComjD7E7er1A,7986
 swarm/blueprints/family_ties/models.py,sha256=C3_okdVVYuu9xOpoKRsaLoGrM2775cS_cU4UKYAkJ9s,903
@@ -53,7 +53,7 @@ swarm/blueprints/whiskeytango_foxtrot/blueprint_whiskeytango_foxtrot.py,sha256=i
 swarm/extensions/__init__.py,sha256=SadbzfxckByaaqzuKPfXMvqmj45-dcMlavlfQYhGnzE,56
 swarm/extensions/blueprint/__init__.py,sha256=VHSlq8q3AeclMsp63f8RXc3vhcZyzHH0uEaYV6AW-ZI,1841
 swarm/extensions/blueprint/agent_utils.py,sha256=YWpANYTaFKAK4inWSirRlvzbHwQAH1wNkgW0esHKIeg,542
-swarm/extensions/blueprint/blueprint_base.py,sha256=vebDxZnQiaz2lhivPYElhZM886BwigJc6EG_zEEG09U,7513
+swarm/extensions/blueprint/blueprint_base.py,sha256=xuwGq2tAGGevpXVkh_bfIuw1RYRJupeTHKPp8EfvEwI,5145
 swarm/extensions/blueprint/blueprint_discovery.py,sha256=oU7q1JeVMP5k52hfTGObDy1Jn2v5lJRufz9BNvP3W58,5531
 swarm/extensions/blueprint/blueprint_utils.py,sha256=Ef_pu-RYomqzFjMg6LOSPSdbYFCbYXjEoSvK1OT49Eo,702
 swarm/extensions/blueprint/cli_handler.py,sha256=ri812w0w2JzXtLSmwfSbpJCCveokgABnTfZEv4Iup2Y,9250
@@ -253,8 +253,8 @@ swarm/views/message_views.py,sha256=sDUnXyqKXC8WwIIMAlWf00s2_a2T9c75Na5FvYMJwBM,
 swarm/views/model_views.py,sha256=aAbU4AZmrOTaPeKMWtoKK7FPYHdaN3Zbx55JfKzYTRY,2937
 swarm/views/utils.py,sha256=geX3Z5ZDKFYyXYBMilc-4qgOSjhujK3AfRtvbXgFpXk,3643
 swarm/views/web_views.py,sha256=ExQQeJpZ8CkLZQC_pXKOOmdnEy2qR3wEBP4LLp27DPU,7404
-open_swarm-0.1.1743371228.dist-info/METADATA,sha256=Ckpb7CTJuopfeFIpw751O2Dcp8QbTbgDZNQttPp31-Y,13680
-open_swarm-0.1.1743371228.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1743371228.dist-info/entry_points.txt,sha256=LudR3dBqGnglrE1n2zAeWo38Ck0m57sKPW36KfK-pzo,71
-open_swarm-0.1.1743371228.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1743371228.dist-info/RECORD,,
+open_swarm-0.1.1743372974.dist-info/METADATA,sha256=blPlP9G_zGz6Vi-7nxiIpWiegGOvObE1FCYtDJJf3aw,13678
+open_swarm-0.1.1743372974.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1743372974.dist-info/entry_points.txt,sha256=LudR3dBqGnglrE1n2zAeWo38Ck0m57sKPW36KfK-pzo,71
+open_swarm-0.1.1743372974.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1743372974.dist-info/RECORD,,

swarm/blueprints/echocraft/blueprint_echocraft.py

@@ -1,6 +1,10 @@
+
+# --- Content for src/swarm/blueprints/echocraft/blueprint_echocraft.py ---
 import logging
-from typing import Dict, List, Any, AsyncGenerator
-# Correct import path for BlueprintBase
+from typing import List, Dict, Any, AsyncGenerator
+import uuid # Import uuid to generate IDs
+import time # Import time for timestamp
+
 from swarm.extensions.blueprint.blueprint_base import BlueprintBase
 
 logger = logging.getLogger(__name__)
@@ -8,37 +12,60 @@ logger = logging.getLogger(__name__)
 class EchoCraftBlueprint(BlueprintBase):
     """
     A simple blueprint that echoes the last user message.
+    Used for testing and demonstrating basic blueprint structure.
     """
-    metadata = {
-        "name": "EchoCraft",
-        "description": "Echoes the last user message.",
-        "author": "SwarmTeam",
-        "version": "1.0",
-        # Example: Specify a default LLM profile if desired
-        # "llm_profile": "default"
-    }
-
-    # *** Make run async and use yield ***
-    async def run(self, messages: List[Dict[str, str]]) -> AsyncGenerator[Dict[str, Any], None]:
+
+    # No specific __init__ needed beyond the base class unless adding more params
+    # def __init__(self, blueprint_id: str, **kwargs):
+    #     super().__init__(blueprint_id=blueprint_id, **kwargs)
+    #     logger.info(f"EchoCraftBlueprint '{self.blueprint_id}' initialized.")
+
+    async def run(self, messages: List[Dict[str, Any]], **kwargs: Any) -> AsyncGenerator[Dict[str, Any], None]:
         """
-        Finds the last user message and yields it back with an 'Echo: ' prefix.
+        Echoes the content of the last message with role 'user'.
+        Yields a final message in OpenAI ChatCompletion format.
         """
         logger.info(f"EchoCraftBlueprint run called with {len(messages)} messages.")
-        last_user_message = "No user message found."
+
+        last_user_message_content = "No user message found."
         for msg in reversed(messages):
             if msg.get("role") == "user":
-                last_user_message = msg.get("content", "")
-                logger.debug(f"Found last user message: {last_user_message}")
+                last_user_message_content = msg.get("content", "(empty content)")
+                logger.debug(f"Found last user message: {last_user_message_content}")
                 break
 
-        response_content = f"Echo: {last_user_message}"
-        logger.info(f"EchoCraftBlueprint yielding: {response_content}")
+        echo_content = f"Echo: {last_user_message_content}"
+        logger.info(f"EchoCraftBlueprint yielding: {echo_content}")
+
+        # --- Format the final output as an OpenAI ChatCompletion object ---
+        completion_id = f"chatcmpl-echo-{uuid.uuid4()}"
+        created_timestamp = int(time.time())
 
-        # Yield the final response in the expected format
-        yield {
-            "messages": [
-                {"role": "assistant", "content": response_content}
-            ]
+        final_message_chunk = {
+            "id": completion_id,
+            "object": "chat.completion",
+            "created": created_timestamp,
+            "model": self.llm_profile_name, # Use profile name as model identifier
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": echo_content,
+                    },
+                    "finish_reason": "stop",
+                    "logprobs": None, # Add null logprobs if needed
+                }
+            ],
+            # Add usage stats if desired/possible
+            # "usage": {
+            #     "prompt_tokens": 0,
+            #     "completion_tokens": 0,
+            #     "total_tokens": 0
+            # }
         }
+        yield final_message_chunk
+        # --- End formatting change ---
+
         logger.info("EchoCraftBlueprint run finished.")
 

swarm/extensions/blueprint/blueprint_base.py

@@ -1,160 +1,111 @@
+
+# --- Content for src/swarm/extensions/blueprint/blueprint_base.py ---
 import logging
-import os
-import inspect
-from typing import Dict, List, Any, AsyncGenerator, Optional, Type
+import json
 from abc import ABC, abstractmethod
-from jinja2 import Environment, FileSystemLoader, select_autoescape
+from typing import Dict, Any, Optional, List, AsyncGenerator
 from pathlib import Path
-import copy
-# *** Import Django settings ***
-from django.conf import settings
-
-# *** REMOVE SwarmConfig import from apps.py ***
-# from swarm.apps import SwarmConfig
+from django.apps import apps # Import Django apps registry
 
-# Import helpers from config_loader if needed directly
-# from swarm.extensions.config.config_loader import find_config_file, DEFAULT_CONFIG_FILENAME
-
-# *** LLMRegistry doesn't exist yet - Comment out import ***
-# from swarm.llm.llm_registry import LLMRegistry # Example path - CHANGE ME!
+# Keep the function import
+from swarm.extensions.config.config_loader import get_profile_from_config
 
 logger = logging.getLogger(__name__)
 
 class BlueprintBase(ABC):
     """
-    Abstract base class for all blueprints.
-    Ensures common interface and configuration handling.
-    """
-    metadata: Dict[str, Any] = {}
+    Abstract base class for all Swarm blueprints.
 
-    @abstractmethod
-    async def run(self, messages: List[Dict[str, str]]) -> AsyncGenerator[Dict[str, Any], None]:
+    Defines the core interface for blueprint initialization and execution.
+    """
+    def __init__(self, blueprint_id: str, config_path: Optional[Path] = None):
         """
-        Asynchronously runs the blueprint logic with the given messages.
-        Must be implemented by subclasses.
+        Initializes the blueprint.
+
+        Args:
+            blueprint_id: A unique identifier for this blueprint instance.
+            config_path: Optional path to a specific swarm_config.json file.
+                         If None, the standard search logic will be used.
         """
-        if False: yield {}
-        pass
-
-    def __init__(
-        self,
-        # config_override: Optional[Dict] = None, # Override logic needs rethink
-        params: Optional[Dict] = None,
-    ):
-        logger.debug(f"BlueprintBase.__init__ starting for {self.__class__.__name__}")
-        self.params = params if params else {}
-        # self._config_override = config_override # Store override for use in _configure
-        # self._resolved_config_path = None # Initialize path tracker
-
-        # Configuration loading needs rethink - access via settings for now
-        self._configure() # This sets self.config attributes from settings
-
-        # Now setup others that might depend on config
-        self._setup_llm() # Uses self.config attributes
-        self._setup_jinja() # Uses class path
-
-        # Logging Adjustment
-        # Check config *after* it has been loaded by _configure
-        # Use self.is_debug which should be set in _configure
-        if hasattr(self, 'is_debug') and self.is_debug:
-             log_level_int = logging.DEBUG
-             if logging.root.level > log_level_int:
-                logger.info(f"Root logger level is {logging.getLevelName(logging.root.level)}. Lowering to DEBUG due to config.")
-                logging.root.setLevel(log_level_int)
-
-        # Ensure llm_profile_name is set by _setup_llm before logging it
-        # Add check if llm_profile_name exists before logging
-        profile_name_to_log = getattr(self, 'llm_profile_name', 'N/A')
-        logger.info(f"Initialized blueprint '{self.metadata.get('name', self.__class__.__name__)}' with profile '{profile_name_to_log}'")
-
-    def _configure(self):
-        """Placeholder: Sets config attributes based on django.conf.settings."""
-        logger.debug("BlueprintBase._configure accessing django.conf.settings")
-        # *** Access settings directly (temporary) ***
-        # This assumes swarm_config.json content is NOT yet loaded into settings
-        # We'll rely on defaults or potentially fail in _setup_llm
-        self.is_debug = getattr(settings, 'DEBUG', False)
-        # Store blueprint-specific parts for convenience - these won't exist in settings yet!
-        self.blueprint_config = {} # Placeholder
-        self.blueprint_defaults = {} # Placeholder
-        logger.warning("_configure is using placeholders. Swarm config file content is not loaded here.")
-
-
-    def _setup_llm(self):
-        """Sets up the LLM provider based on configuration stored in self.config."""
-        # *** Access settings directly (temporary) ***
-        # Get default profile name from settings if defined, else 'default'
-        default_profile = getattr(settings, 'DEFAULT_LLM_PROFILE', 'default')
-        self.llm_profile_name = self.blueprint_config.get('llm_profile', default_profile) # Use placeholder blueprint_config
-        logger.debug(f"Getting LLM profile details for '{self.llm_profile_name}'.")
-
-        # *** This part will likely fail or use defaults as swarm_config isn't in settings ***
-        # Attempt to get profiles from settings if they were somehow loaded there
-        all_llm_profiles = getattr(settings, 'LLM_PROFILES', {})
-        profile_data = all_llm_profiles.get(self.llm_profile_name)
-
-        if profile_data is None:
-            logger.warning(f"LLM profile '{self.llm_profile_name}' not found in django settings. LLM will not be available.")
-            self.llm_profile = {} # Set empty profile
-            self.llm = None # Set LLM to None
-            return # Exit setup early
-
-        logger.debug(f"Using LLM profile '{self.llm_profile_name}' from settings.")
-        self.llm_profile = profile_data
-        # *** LLMRegistry doesn't exist yet - Comment out usage and set placeholder ***
-        # self.llm = LLMRegistry.get_llm(self.llm_profile)
-        self.llm = None # Placeholder until registry is implemented
-        logger.warning("LLMRegistry not implemented. self.llm set to None.")
-
-
-    @staticmethod
-    def _substitute_env_vars(data: Any) -> Any:
-        """Recursively substitutes environment variables in strings."""
-        if isinstance(data, dict):
-            return {k: BlueprintBase._substitute_env_vars(v) for k, v in data.items()}
-        if isinstance(data, list):
-            return [BlueprintBase._substitute_env_vars(item) for item in data]
-        if isinstance(data, str):
-            return os.path.expandvars(data)
-        return data
-
-    def _setup_jinja(self):
-        """Sets up Jinja2 environment."""
+        if not blueprint_id:
+             raise ValueError("blueprint_id cannot be empty or None") # Add validation
+        self.blueprint_id = blueprint_id
+        self.config_path = config_path # Note: config_path is currently unused if we rely on AppConfig
+        self._config: Optional[Dict[str, Any]] = None
+        self._llm_profile_name: Optional[str] = None
+        self._llm_profile_data: Optional[Dict[str, Any]] = None
+        self._markdown_output: bool = True # Default
+
+        logger.info(f"Initializing blueprint '{self.blueprint_id}' (Type: {self.__class__.__name__})")
+        self._load_and_process_config()
+
+    def _load_and_process_config(self):
+        """Loads the main Swarm config and extracts relevant settings."""
         try:
-            blueprint_file_path = inspect.getfile(self.__class__)
-            blueprint_dir = os.path.dirname(blueprint_file_path)
-            template_dir = os.path.join(blueprint_dir, 'templates')
-            if os.path.isdir(template_dir):
-                 logger.debug(f"Setting up Jinja env with loader at: {template_dir}")
-                 self.jinja_env = Environment(
-                     loader=FileSystemLoader(template_dir),
-                     autoescape=select_autoescape(['html', 'xml'])
-                 )
-            else:
-                 logger.debug(f"No 'templates' directory found for blueprint at {template_dir}. Jinja env not created.")
-                 self.jinja_env = None
+            # --- Get config from the AppConfig instance ---
+            app_config_instance = apps.get_app_config('swarm')
+            # Assuming the loaded config is stored in an attribute named 'config'
+            # Adjust 'config' if your AppConfig uses a different attribute name
+            if not hasattr(app_config_instance, 'config') or not app_config_instance.config:
+                 logger.error("Swarm configuration not found on AppConfig instance. Was ready() called?")
+                 raise ValueError("Swarm configuration unavailable via AppConfig.")
+            self._config = app_config_instance.config
+            # --- End change ---
+
+            logger.debug(f"Blueprint '{self.blueprint_id}' using loaded Swarm config.")
+
+            # Determine LLM profile
+            self._llm_profile_name = self._config.get("settings", {}).get("default_llm_profile", "default")
+            logger.debug(f"Attempting to use LLM profile: '{self._llm_profile_name}'")
+
+            # Get substituted profile data
+            self._llm_profile_data = get_profile_from_config(self._config, self._llm_profile_name)
+            logger.info(f"Successfully loaded LLM profile '{self._llm_profile_name}'. Provider: {self._llm_profile_data.get('provider')}")
+
+            # Get markdown setting
+            blueprint_specific_settings = self._config.get("blueprints", {}).get(self.blueprint_id, {})
+            global_markdown_setting = self._config.get("settings", {}).get("default_markdown_output", True)
+            self._markdown_output = blueprint_specific_settings.get("markdown_output", global_markdown_setting)
+            logger.debug(f"Markdown output for '{self.blueprint_id}': {self._markdown_output}")
+
+        except ValueError as e:
+            logger.error(f"Configuration error for blueprint '{self.blueprint_id}': {e}", exc_info=True)
+            raise
         except Exception as e:
-             logger.warning(f"Could not determine template path for {self.__class__.__name__}: {e}. Jinja env not created.")
-             self.jinja_env = None
-
-    def render_prompt(self, template_name: str, context: Dict = None) -> str:
-        """Renders a Jinja2 template."""
-        if not self.jinja_env:
-             raise RuntimeError(f"Jinja environment not set up for blueprint {self.__class__.__name__}.")
-        if context is None:
-             context = {}
-        try:
-             template = self.jinja_env.get_template(template_name)
-             full_context = {**self.params, **context}
-             return template.render(full_context)
-        except Exception as e:
-             logger.error(f"Error rendering template '{template_name}': {e}", exc_info=True)
-             raise
-
-    def get_llm_profile(self) -> Dict:
-         """Returns the configuration for the LLM profile being used."""
-         if not hasattr(self, 'llm_profile'):
-              logger.warning("LLM profile was not set during initialization, returning empty dict.")
-              return {}
-         return self.llm_profile
+            logger.error(f"Unexpected error loading config for blueprint '{self.blueprint_id}': {e}", exc_info=True)
+            raise
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        """Returns the loaded and processed Swarm configuration."""
+        if self._config is None:
+            raise RuntimeError("Configuration accessed before initialization or after failure.")
+        return self._config
+
+    @property
+    def llm_profile(self) -> Dict[str, Any]:
+        """Returns the loaded and processed LLM profile data for this blueprint."""
+        if self._llm_profile_data is None:
+            raise RuntimeError("LLM profile accessed before initialization or after failure.")
+        return self._llm_profile_data
+
+    @property
+    def llm_profile_name(self) -> str:
+        """Returns the name of the LLM profile being used."""
+        if self._llm_profile_name is None:
+             raise RuntimeError("LLM profile name accessed before initialization or after failure.")
+        return self._llm_profile_name
+
+    @property
+    def should_output_markdown(self) -> bool:
+        """Returns whether the blueprint should format output as Markdown."""
+        return self._markdown_output
+
+    @abstractmethod
+    async def run(self, messages: List[Dict[str, Any]], **kwargs: Any) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        The main execution method for the blueprint.
+        """
+        raise NotImplementedError("Subclasses must implement the 'run' method.")
+        yield {}