open-swarm 0.1.1743070217__py3-none-any.whl

swarm/messages.py

@@ -0,0 +1,132 @@
+"""
+Message handling utilities for the Swarm framework.
+Defines the ChatMessage structure.
+"""
+
+import json
+import logging
+from types import SimpleNamespace
+from typing import Optional, List, Dict, Any, Union
+
+# Import the specific Pydantic model used for tool calls
+from .types import ChatCompletionMessageToolCall
+
+# Configure module-level logging
+logger = logging.getLogger(__name__)
+# logger.setLevel(logging.DEBUG) # Uncomment for detailed message logging
+if not logger.handlers:
+    stream_handler = logging.StreamHandler()
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s:%(lineno)d - %(message)s")
+    stream_handler.setFormatter(formatter)
+    logger.addHandler(stream_handler)
+
+
+class ChatMessage(SimpleNamespace):
+    """
+    Represents a chat message within the Swarm framework, aiming for compatibility
+    with OpenAI's chat completion message structure while allowing custom fields.
+
+    Attributes:
+        role (str): The role of the message sender (e.g., "system", "user", "assistant", "tool").
+        content (Optional[str]): The text content of the message. Can be None for assistant messages
+                                 requesting tool calls without initial text.
+        sender (str): Custom field identifying the specific agent or source (not sent to LLM API).
+        function_call (Optional[dict]): Deprecated field for legacy function calls.
+        tool_calls (Optional[List[ChatCompletionMessageToolCall]]): A list of tool calls requested
+                                                                    by the assistant.
+        tool_call_id (Optional[str]): Identifier for a tool response message, linking it to a specific
+                                     tool_call requested by the assistant.
+        name (Optional[str]): The name of the tool that was called (used in 'tool' role messages).
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize a ChatMessage instance.
+
+        Args:
+            **kwargs: Arbitrary keyword arguments mapping to message attributes.
+                      Defaults are provided for common fields.
+        """
+        # Define default values for standard message attributes
+        defaults = {
+            "role": "assistant", # Default role
+            "content": None, # Default content to None (as per OpenAI spec for tool calls)
+            "sender": "assistant", # Default custom sender
+            "function_call": None, # Deprecated field
+            "tool_calls": None, # For assistant requests
+            "tool_call_id": None, # For tool responses
+            "name": None # For tool responses (function name)
+        }
+        # Merge provided kwargs with defaults
+        merged_attrs = defaults | kwargs
+        super().__init__(**merged_attrs)
+
+        # --- Validation and Type Conversion for tool_calls ---
+        # Ensure tool_calls, if present, is a list
+        if self.tool_calls is not None and not isinstance(self.tool_calls, list):
+            logger.warning(f"ChatMessage 'tool_calls' received non-list type ({type(self.tool_calls)}) for sender '{self.sender}'. Resetting to None.")
+            self.tool_calls = None
+        elif isinstance(self.tool_calls, list):
+            # Convert dictionary items in the list to ChatCompletionMessageToolCall objects
+            validated_tool_calls = []
+            for i, tc in enumerate(self.tool_calls):
+                if isinstance(tc, ChatCompletionMessageToolCall):
+                    validated_tool_calls.append(tc)
+                elif isinstance(tc, dict):
+                    try:
+                        # Attempt to instantiate the Pydantic model
+                        validated_tool_calls.append(ChatCompletionMessageToolCall(**tc))
+                    except Exception as e: # Catch potential validation errors from Pydantic
+                        logger.warning(f"Failed to convert dict to ChatCompletionMessageToolCall at index {i} for sender '{self.sender}': {e}. Skipping this tool call.")
+                        logger.debug(f"Invalid tool call dict: {tc}")
+                else:
+                    logger.warning(f"Invalid item type in 'tool_calls' list at index {i} ({type(tc)}) for sender '{self.sender}'. Skipping.")
+            self.tool_calls = validated_tool_calls if validated_tool_calls else None # Set back validated list or None if empty/all invalid
+            if self.tool_calls:
+                 logger.debug(f"Validated {len(self.tool_calls)} tool calls for ChatMessage (sender: '{self.sender}')")
+
+
+    def model_dump(self) -> Dict[str, Any]:
+         """
+         Serialize the message attributes relevant for the OpenAI API into a dictionary.
+         Excludes custom fields like 'sender'. Handles optional fields correctly.
+         """
+         # Start with required 'role'
+         d: Dict[str, Any] = {"role": self.role}
+
+         # Include 'content' only if it's not None
+         # OpenAI API allows null content for assistant messages with tool_calls
+         if self.content is not None:
+             d["content"] = self.content
+
+         # Include 'tool_calls' if present and not empty
+         if self.tool_calls: # Checks for non-None and non-empty list after validation
+             # Ensure each item is dumped correctly using its own model_dump if available
+             d["tool_calls"] = [tc.model_dump() if hasattr(tc, 'model_dump') else tc for tc in self.tool_calls]
+
+         # Include 'tool_call_id' if present (for 'tool' role messages)
+         if self.tool_call_id is not None:
+             d["tool_call_id"] = self.tool_call_id
+
+         # Include 'name' if present (for 'tool' role messages, matches function name)
+         if self.name is not None:
+              d["name"] = self.name
+
+         # Include deprecated 'function_call' if present
+         if self.function_call is not None:
+             d["function_call"] = self.function_call
+
+         return d
+
+
+    def model_dump_json(self) -> str:
+        """Serialize the message to a JSON string suitable for the OpenAI API."""
+        # Use the model_dump method to get the correct dictionary structure first
+        api_dict = self.model_dump()
+        # Serialize the dictionary to JSON
+        try:
+            return json.dumps(api_dict)
+        except TypeError as e:
+             logger.error(f"Failed to serialize ChatMessage to JSON for sender '{self.sender}': {e}")
+             # Fallback: return a basic JSON representation on error
+             return json.dumps({"role": self.role, "content": f"[Serialization Error: {e}]"})

swarm/migrations/0010_initial_chat_models.py

@@ -0,0 +1,51 @@
+# Generated manually on 2025-02-24 to establish core Swarm chat models
+
+from django.db import migrations, models
+import django.db.models.deletion
+from django.conf import settings
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='ChatConversation',
+            fields=[
+                ('conversation_id', models.CharField(max_length=255, primary_key=True, serialize=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('student', models.ForeignKey(
+                    blank=True,
+                    null=True,
+                    on_delete=django.db.models.deletion.CASCADE,
+                    to=settings.AUTH_USER_MODEL,
+                )),
+            ],
+            options={
+                'verbose_name': 'Chat Conversation',
+                'verbose_name_plural': 'Chat Conversations',
+            },
+        ),
+        migrations.CreateModel(
+            name='ChatMessage',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('sender', models.CharField(max_length=50)),
+                ('content', models.TextField()),
+                ('timestamp', models.DateTimeField(auto_now_add=True)),
+                ('tool_call_id', models.CharField(blank=True, max_length=255, null=True)),
+                ('conversation', models.ForeignKey(
+                    on_delete=django.db.models.deletion.CASCADE,
+                    related_name='chat_messages',
+                    to='swarm.chatconversation',
+                )),
+            ],
+            options={
+                'ordering': ['timestamp'],
+                'verbose_name': 'Chat Message',
+                'verbose_name_plural': 'Chat Messages',
+            },
+        ),
+    ]

swarm/models.py

@@ -0,0 +1,45 @@
+from django.db import models
+
+class ChatConversation(models.Model):
+    """Represents a single chat session."""
+    conversation_id = models.CharField(max_length=255, primary_key=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    student = models.ForeignKey("auth.User", on_delete=models.CASCADE, blank=True, null=True)
+
+    class Meta:
+        app_label = "swarm"
+        verbose_name = "Chat Conversation"
+        verbose_name_plural = "Chat Conversations"
+
+    def __str__(self):
+        return f"ChatConversation({self.conversation_id})"
+
+    @property
+    def messages(self):
+        return self.chat_messages.all()
+
+class ChatMessage(models.Model):
+    """Stores individual chat messages within a conversation."""
+    conversation = models.ForeignKey(ChatConversation, related_name="chat_messages", on_delete=models.CASCADE)
+    sender = models.CharField(max_length=50)
+    content = models.TextField()
+    timestamp = models.DateTimeField(auto_now_add=True)
+    tool_call_id = models.CharField(max_length=255, blank=True, null=True)
+
+    class Meta:
+        ordering = ["timestamp"]
+        verbose_name = "Chat Message"
+        verbose_name_plural = "Chat Messages"
+
+    def __str__(self):
+        return self.content[:50]
+
+__all__ = [
+    "ChatConversation",
+    "ChatMessage",
+]
+
+# Alias the module to prevent conflicting model registrations.
+import sys
+sys.modules["swarm.models"] = sys.modules[__name__]
+sys.modules["src.swarm.models"] = sys.modules["swarm.models"]

swarm/repl/__init__.py

@@ -0,0 +1 @@
+from .repl import run_demo_loop

swarm/repl/repl.py

@@ -0,0 +1,87 @@
+import json
+
+from swarm import Swarm
+
+
+def process_and_print_streaming_response(response):
+    content = ""
+    last_sender = ""
+
+    for chunk in response:
+        if "sender" in chunk:
+            last_sender = chunk["sender"]
+
+        if "content" in chunk and chunk["content"] is not None:
+            if not content and last_sender:
+                print(f"\033[94m{last_sender}:\033[0m", end=" ", flush=True)
+                last_sender = ""
+            print(chunk["content"], end="", flush=True)
+            content += chunk["content"]
+
+        if "tool_calls" in chunk and chunk["tool_calls"] is not None:
+            for tool_call in chunk["tool_calls"]:
+                f = tool_call["function"]
+                name = f["name"]
+                if not name:
+                    continue
+                print(f"\033[94m{last_sender}: \033[95m{name}\033[0m()")
+
+        if "delim" in chunk and chunk["delim"] == "end" and content:
+            print()  # End of response message
+            content = ""
+
+        if "response" in chunk:
+            return chunk["response"]
+
+
+def pretty_print_messages(messages) -> None:
+    for message in messages:
+        if message["role"] != "assistant":
+            continue
+
+        # print agent name in blue
+        print(f"\033[94m{message['sender']}\033[0m:", end=" ")
+
+        # print response, if any
+        if message["content"]:
+            print(message["content"])
+
+        # print tool calls in purple, if any
+        tool_calls = message.get("tool_calls") or []
+        if len(tool_calls) > 1:
+            print()
+        for tool_call in tool_calls:
+            f = tool_call["function"]
+            name, args = f["name"], f["arguments"]
+            arg_str = json.dumps(json.loads(args)).replace(":", "=")
+            print(f"\033[95m{name}\033[0m({arg_str[1:-1]})")
+
+
+def run_demo_loop(
+    starting_agent, context_variables=None, stream=False, debug=False
+) -> None:
+    client = Swarm()
+    print("Starting Swarm CLI 🐝")
+
+    messages = []
+    agent = starting_agent
+
+    while True:
+        user_input = input("\033[90mUser\033[0m: ")
+        messages.append({"role": "user", "content": user_input})
+
+        response = client.run(
+            agent=agent,
+            messages=messages,
+            context_variables=context_variables or {},
+            stream=stream,
+            debug=debug,
+        )
+
+        if stream:
+            response = process_and_print_streaming_response(response)
+        else:
+            pretty_print_messages(response.messages)
+
+        messages.extend(response.messages)
+        agent = response.agent

swarm/serializers.py

@@ -0,0 +1,12 @@
+from rest_framework import serializers
+from swarm.models import ChatMessage, ChatConversation
+
+class ChatMessageSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ChatMessage
+        fields = '__all__'
+
+class ChatConversationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ChatConversation
+        fields = '__all__'

swarm/settings.py

@@ -0,0 +1,189 @@
+"""
+Django settings for swarm project.
+Includes Pydantic base settings for Swarm Core.
+"""
+
+import logging
+import os
+import sys
+from enum import Enum
+from pathlib import Path
+from pydantic import Field # Import Field from Pydantic v2+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# --- Pydantic Settings for Swarm Core ---
+class LogFormat(str, Enum):
+    standard = "[%(levelname)s] %(asctime)s - %(name)s:%(lineno)d - %(message)s"
+    simple = "[%(levelname)s] %(name)s - %(message)s"
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix='SWARM_', case_sensitive=False)
+
+    log_level: str = Field(default='INFO', description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)")
+    log_format: LogFormat = Field(default=LogFormat.standard, description="Logging format")
+    debug: bool = Field(default=False, description="Global debug flag")
+
+# --- Standard Django Settings ---
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+PROJECT_ROOT = BASE_DIR.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+BLUEPRINTS_DIR = PROJECT_ROOT / 'blueprints'
+
+# --- Determine if running under pytest ---
+TESTING = 'pytest' in sys.modules
+
+# Quick-start development settings - unsuitable for production
+SECRET_KEY = os.getenv('DJANGO_SECRET_KEY', 'django-insecure-YOUR_FALLBACK_KEY_HERE_CHANGE_ME')
+# Use the Pydantic setting value for Django's DEBUG
+DEBUG = Settings().debug # Read from instantiated Pydantic settings
+ALLOWED_HOSTS = os.getenv('DJANGO_ALLOWED_HOSTS', '*').split(',')
+
+# --- Application definition ---
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    # Third-party apps
+    'rest_framework',
+    'rest_framework.authtoken',
+    'drf_spectacular',
+    # Local apps
+    'swarm.apps.SwarmConfig',
+]
+
+# --- Conditionally add blueprint apps for TESTING ---
+if TESTING:
+    _test_apps_to_add = ['blueprints.university']
+    for app in _test_apps_to_add:
+        if app not in INSTALLED_APPS:
+            INSTALLED_APPS.insert(0, app)
+            logging.info(f"Settings [TESTING]: Added '{app}' to INSTALLED_APPS.")
+    if 'SWARM_BLUEPRINTS' not in os.environ:
+         os.environ['SWARM_BLUEPRINTS'] = 'university'
+         logging.info(f"Settings [TESTING]: Set SWARM_BLUEPRINTS='university'")
+else:
+    # --- Dynamic App Loading for Production/Development ---
+    _INITIAL_BLUEPRINT_APPS = []
+    _swarm_blueprints_env = os.getenv('SWARM_BLUEPRINTS')
+    _log_source = "Not Set"
+    if _swarm_blueprints_env:
+        _blueprint_names = [name.strip() for name in _swarm_blueprints_env.split(',') if name.strip()]
+        _INITIAL_BLUEPRINT_APPS = [f'blueprints.{name}' for name in _blueprint_names if name.replace('_', '').isidentifier()]
+        _log_source = "SWARM_BLUEPRINTS env var"
+        logging.info(f"Settings: Found blueprints from env var: {_INITIAL_BLUEPRINT_APPS}")
+    else:
+        _log_source = "directory scan"
+        try:
+            if BLUEPRINTS_DIR.is_dir():
+                 for item in BLUEPRINTS_DIR.iterdir():
+                     if item.is_dir() and (item / '__init__.py').exists():
+                         if item.name.replace('_', '').isidentifier():
+                             _INITIAL_BLUEPRINT_APPS.append(f'blueprints.{item.name}')
+            logging.info(f"Settings: Found blueprints from directory scan: {_INITIAL_BLUEPRINT_APPS}")
+        except Exception as e:
+            logging.error(f"Settings: Error discovering blueprint apps during initial load: {e}")
+
+    for app in _INITIAL_BLUEPRINT_APPS:
+         if app not in INSTALLED_APPS:
+              INSTALLED_APPS.append(app)
+              logging.info(f"Settings [{_log_source}]: Added '{app}' to INSTALLED_APPS.")
+# --- End App Loading Logic ---
+
+if isinstance(INSTALLED_APPS, tuple): INSTALLED_APPS = list(INSTALLED_APPS)
+logging.info(f"Settings: Final INSTALLED_APPS = {INSTALLED_APPS}")
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'swarm.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [BASE_DIR / 'templates'],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'swarm.wsgi.application'
+
+SQLITE_DB_PATH = os.getenv('SQLITE_DB_PATH', BASE_DIR / 'db.sqlite3')
+DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': SQLITE_DB_PATH } }
+DJANGO_DATABASE = DATABASES['default']
+
+AUTH_PASSWORD_VALIDATORS = [
+    {'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'},
+]
+
+LANGUAGE_CODE = 'en-us'; TIME_ZONE = 'UTC'; USE_I18N = True; USE_TZ = True
+
+STATIC_URL = '/static/'; STATIC_ROOT = BASE_DIR / 'staticfiles'
+STATICFILES_DIRS = [ BASE_DIR / 'static', BASE_DIR / 'assets' ]
+
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+
+REST_FRAMEWORK = {
+    'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',
+    'DEFAULT_AUTHENTICATION_CLASSES': (
+        'swarm.auth.EnvOrTokenAuthentication',
+        'rest_framework.authentication.TokenAuthentication',
+        'rest_framework.authentication.SessionAuthentication',
+    ),
+    'DEFAULT_PERMISSION_CLASSES': ('rest_framework.permissions.IsAuthenticated',)
+}
+
+SPECTACULAR_SETTINGS = {
+    'TITLE': 'Open Swarm API',
+    'DESCRIPTION': 'API for the Open Swarm multi-agent collaboration framework.',
+    'VERSION': '1.0.0',
+    'SERVE_INCLUDE_SCHEMA': False,
+    'SERVE_PERMISSIONS': ['rest_framework.permissions.AllowAny'],
+}
+
+LOGGING = {
+    'version': 1, 'disable_existing_loggers': False,
+    'formatters': { 'standard': { 'format': '[%(levelname)s] %(asctime)s - %(name)s:%(lineno)d - %(message)s' }, },
+    'handlers': { 'console': { 'level': 'DEBUG' if DEBUG else 'INFO', 'class': 'logging.StreamHandler', 'formatter': 'standard', }, },
+    'loggers': {
+        'django': { 'handlers': ['console'], 'level': 'INFO', 'propagate': False, },
+        'django.request': { 'handlers': ['console'], 'level': 'WARNING', 'propagate': False, },
+        'swarm': { 'handlers': ['console'], 'level': 'DEBUG' if DEBUG else 'INFO', 'propagate': False, },
+        'swarm.extensions': { 'handlers': ['console'], 'level': 'DEBUG' if DEBUG else 'INFO', 'propagate': False, },
+        'blueprints': { 'handlers': ['console'], 'level': 'DEBUG' if DEBUG else 'INFO', 'propagate': False, },
+    },
+}
+
+AUTHENTICATION_BACKENDS = ['django.contrib.auth.backends.ModelBackend']
+LOGIN_URL = '/accounts/login/'; LOGIN_REDIRECT_URL = '/chatbot/'
+
+REDIS_HOST = os.getenv('REDIS_HOST', 'localhost')
+REDIS_PORT = int(os.getenv('REDIS_PORT', 6379))
+
+if TESTING:
+     print("Pytest detected: Adjusting settings for testing.")
+     DATABASES['default']['NAME'] = ':memory:'