open-swarm 0.1.1745275181__py3-none-any.whl → 0.1.1748636295__py3-none-any.whl

swarm/llm/chat_completion.py

@@ -0,0 +1,166 @@
+"""
+Chat Completion Module
+
+This module handles chat completion logic for the Swarm framework, including message preparation,
+tool call repair, and interaction with the OpenAI API. Located in llm/ for LLM-specific functionality.
+"""
+
+import os
+import json
+import logging
+from typing import List, Optional, Dict, Any
+from collections import defaultdict
+
+import asyncio
+from openai import AsyncOpenAI, OpenAIError
+from ..types import ChatCompletionMessage, Agent
+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
+from ..utils.message_sequence import repair_message_payload
+
+# Configure module-level logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+if not logger.handlers:
+    stream_handler = logging.StreamHandler()
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    stream_handler.setFormatter(formatter)
+    logger.addHandler(stream_handler)
+
+
+async def get_chat_completion(
+    client: AsyncOpenAI,
+    agent: Agent,
+    history: List[Dict[str, Any]],
+    context_variables: dict,
+    current_llm_config: Dict[str, Any],
+    max_context_tokens: int,
+    max_context_messages: int,
+    model_override: Optional[str] = None,
+    stream: bool = False,
+    debug: bool = False
+) -> ChatCompletionMessage:
+    """
+    Retrieve a chat completion from the LLM for the given agent and history.
+
+    Args:
+        client: AsyncOpenAI client instance.
+        agent: The agent processing the completion.
+        history: List of previous messages in the conversation.
+        context_variables: Variables to include in the agent's context.
+        current_llm_config: Current LLM configuration dictionary.
+        max_context_tokens: Maximum token limit for context.
+        max_context_messages: Maximum message limit for context.
+        model_override: Optional model to use instead of default.
+        stream: If True, stream the response; otherwise, return complete.
+        debug: If True, log detailed debugging information.
+
+    Returns:
+        ChatCompletionMessage: The LLM's response message.
+    """
+    if not agent:
+        logger.error("Cannot generate chat completion: Agent is None")
+        raise ValueError("Agent is required")
+
+    logger.debug(f"Generating chat completion for agent '{agent.name}'")
+    active_model = model_override or current_llm_config.get("model", "default")
+    client_kwargs = {
+        "api_key": current_llm_config.get("api_key"),
+        "base_url": current_llm_config.get("base_url")
+    }
+    client_kwargs = {k: v for k, v in client_kwargs.items() if v is not None}
+    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']}")
+
+    context_variables = defaultdict(str, context_variables)
+    instructions = agent.instructions(context_variables) if callable(agent.instructions) else agent.instructions
+    if not isinstance(instructions, str):
+        logger.warning(f"Invalid instructions type for '{agent.name}': {type(instructions)}. Converting to string.")
+        instructions = str(instructions)
+    messages = repair_message_payload([{"role": "system", "content": instructions}], debug=debug)
+
+    if not isinstance(history, list):
+        logger.error(f"Invalid history type for '{agent.name}': {type(history)}. Expected list.")
+        history = []
+    seen_ids = set()
+    for msg in history:
+        msg_id = msg.get("id", hash(json.dumps(msg, sort_keys=True, default=serialize_datetime)))
+        if msg_id not in seen_ids:
+            seen_ids.add(msg_id)
+            if "tool_calls" in msg and msg["tool_calls"] is not None and not isinstance(msg["tool_calls"], list):
+                logger.warning(f"Invalid tool_calls in history for '{msg.get('sender', 'unknown')}': {msg['tool_calls']}. Setting to None.")
+                msg["tool_calls"] = None
+            messages.append(msg)
+    messages = filter_duplicate_system_messages(messages)
+    messages = truncate_message_history(messages, active_model, max_context_tokens, max_context_messages)
+    messages = repair_message_payload(messages, debug=debug)  # Ensure tool calls are paired post-truncation
+
+    logger.debug(f"Prepared {len(messages)} messages for '{agent.name}'")
+    if debug:
+        logger.debug(f"Messages: {json.dumps(messages, indent=2, default=str)}")
+
+    create_params = {
+        "model": active_model,
+        "messages": messages,
+        "stream": stream,
+        "temperature": current_llm_config.get("temperature", 0.7),
+    }
+    if getattr(agent, "response_format", None):
+        create_params["response_format"] = agent.response_format
+    create_params = {k: v for k, v in create_params.items() if v is not None}
+    logger.debug(f"Chat completion params: model='{active_model}', messages_count={len(messages)}, stream={stream}")
+
+    try:
+        logger.debug(f"Calling OpenAI API for '{agent.name}' with model='{active_model}'")
+        prev_openai_api_key = os.environ.pop("OPENAI_API_KEY", None)
+        try:
+            completion = await client.chat.completions.create(**create_params)
+            if stream:
+                return completion  # Return stream object directly
+            if completion.choices and len(completion.choices) > 0 and completion.choices[0].message:
+                log_msg = completion.choices[0].message.content[:50] if completion.choices[0].message.content else "No content"
+                logger.debug(f"OpenAI completion received for '{agent.name}': {log_msg}...")
+                return completion.choices[0].message
+            else:
+                logger.warning(f"No valid message in completion for '{agent.name}'")
+                return ChatCompletionMessage(content="No response generated", role="assistant")
+        finally:
+            if prev_openai_api_key is not None:
+                os.environ["OPENAI_API_KEY"] = prev_openai_api_key
+    except OpenAIError as e:
+        logger.error(f"Chat completion failed for '{agent.name}': {e}")
+        raise
+
+
+async def get_chat_completion_message(
+    client: AsyncOpenAI,
+    agent: Agent,
+    history: List[Dict[str, Any]],
+    context_variables: dict,
+    current_llm_config: Dict[str, Any],
+    max_context_tokens: int,
+    max_context_messages: int,
+    model_override: Optional[str] = None,
+    stream: bool = False,
+    debug: bool = False
+) -> ChatCompletionMessage:
+    """
+    Wrapper to retrieve and validate a chat completion message.
+
+    Args:
+        Same as get_chat_completion.
+
+    Returns:
+        ChatCompletionMessage: Validated LLM response message.
+    """
+    logger.debug(f"Fetching chat completion message for '{agent.name}'")
+    completion = await get_chat_completion(
+        client, agent, history, context_variables, current_llm_config,
+        max_context_tokens, max_context_messages, model_override, stream, debug
+    )
+    if isinstance(completion, ChatCompletionMessage):
+        return completion
+    logger.warning(f"Unexpected completion type: {type(completion)}. Converting to ChatCompletionMessage.")
+    return ChatCompletionMessage(content=str(completion), role="assistant")

swarm/serializers.py

@@ -1,103 +1,12 @@
 from rest_framework import serializers
-from swarm.models import ChatMessage
-import logging
-
-logger = logging.getLogger(__name__)
-print_logger = logging.getLogger('print_debug')
-
-class MessageSerializer(serializers.Serializer):
-    role = serializers.ChoiceField(choices=["system", "user", "assistant", "tool"])
-    # Content is CharField, allows null/blank by default
-    content = serializers.CharField(allow_null=True, required=False, allow_blank=True)
-    name = serializers.CharField(required=False, allow_blank=True)
-
-    # Removed validate_content
-
-    def validate(self, data):
-        """Validate message structure based on role."""
-        print_logger.debug(f"MessageSerializer.validate received data: {data}")
-        role = data.get('role')
-        content = data.get('content', None)
-        name = data.get('name')
-
-        # Role validation
-        if 'role' not in data:
-             raise serializers.ValidationError({"role": ["This field is required."]})
-
-        # Content requiredness validation (based on role)
-        content_required = role in ['system', 'user', 'assistant', 'tool']
-        content_present = 'content' in data
-
-        if content_required:
-            if not content_present:
-                 raise serializers.ValidationError({"content": ["This field is required."]})
-            # Null/Blank checks are handled by field definition (allow_null/allow_blank)
-            # Type check will happen in ChatCompletionRequestSerializer.validate_messages
-
-        # Name validation for tool role
-        if role == 'tool' and not name:
-             raise serializers.ValidationError({"name": ["This field is required for role 'tool'."]})
-
-        print_logger.debug(f"MessageSerializer.validate PASSED for data: {data}")
-        return data
-
-class ChatCompletionRequestSerializer(serializers.Serializer):
-    model = serializers.CharField(max_length=255)
-    messages = MessageSerializer(many=True, min_length=1)
-    stream = serializers.BooleanField(default=False)
-    params = serializers.JSONField(required=False, allow_null=True)
-
-    def validate(self, data):
-        """Perform object-level validation."""
-        model_value = self.initial_data.get('model')
-        logger.debug(f"Top-level validate checking model type. Got: {type(model_value)}, value: {model_value}")
-        if model_value is not None and not isinstance(model_value, str):
-             raise serializers.ValidationError({"model": ["Field 'model' must be a string."]})
-        # Messages validation (including content type) happens in validate_messages
-        return data
-
-    def validate_messages(self, value):
-        """
-        Validate the messages list itself and perform raw type checks.
-        'value' here is the list *after* MessageSerializer has run on each item.
-        We need to inspect `self.initial_data` for the raw types.
-        """
-        if not value:
-            raise serializers.ValidationError("Messages list cannot be empty.")
-
-        # Access raw message data from initial_data for type checking
-        raw_messages = self.initial_data.get('messages', [])
-        if not isinstance(raw_messages, list):
-             # This case is handled by ListField implicitly, but good to be explicit
-             raise serializers.ValidationError("Expected a list of message items.")
-
-        errors = []
-        for i, raw_msg in enumerate(raw_messages):
-             msg_errors = {}
-             if not isinstance(raw_msg, dict):
-                 # If the item itself isn't a dict, add error and skip further checks for it
-                 errors.append({f"item_{i}": "Each message must be a dictionary."})
-                 continue
-
-             # *** Check raw content type here ***
-             content = raw_msg.get('content', None)
-             if 'content' in raw_msg and content is not None and not isinstance(content, str):
-                  msg_errors['content'] = ["Content must be a string or null."] # Match test assertion
-
-             # Add other raw checks if needed (e.g., role type)
-
-             if msg_errors:
-                  errors.append(msg_errors) # Append errors for this specific message index
-
-        if errors:
-             # Raise a single validation error containing all message-specific errors
-             raise serializers.ValidationError(errors)
-
-        # Return the processed 'value' which passed MessageSerializer validation
-        return value
+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

@@ -3,44 +3,27 @@ Django settings for swarm project.
 """
 
 import os
+import sys
 from pathlib import Path
-from dotenv import load_dotenv
 import logging
 
-BASE_DIR = Path(__file__).resolve().parent.parent # Points to src/
+# 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))
 
-# --- 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}")
-# ---
+BLUEPRINTS_DIR = PROJECT_ROOT / 'blueprints'
 
-SECRET_KEY = os.getenv('DJANGO_SECRET_KEY', 'django-insecure-fallback-key-for-dev')
-DEBUG = os.getenv('DJANGO_DEBUG', 'True').lower() in ('true', '1', 't')
-ALLOWED_HOSTS = os.getenv('DJANGO_ALLOWED_HOSTS', 'localhost,127.0.0.1').split(',')
+# --- Determine if running under pytest ---
+TESTING = 'pytest' in sys.modules
 
-# --- Custom Swarm Settings ---
-# Load the token from environment
-_raw_api_token = os.getenv('API_AUTH_TOKEN')
-
-# *** Only enable API auth if the token is actually set ***
-ENABLE_API_AUTH = bool(_raw_api_token)
-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.")
-else:
-    # 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'))
-# --- End Custom Swarm Settings ---
+# Quick-start development settings - unsuitable for production
+SECRET_KEY = os.getenv('DJANGO_SECRET_KEY', 'django-insecure-YOUR_FALLBACK_KEY_HERE_CHANGE_ME')
+DEBUG = os.getenv('DEBUG', 'True') == 'True'
+ALLOWED_HOSTS = os.getenv('DJANGO_ALLOWED_HOSTS', '*').split(',')
 
+# --- Application definition ---
 INSTALLED_APPS = [
     'django.contrib.admin',
     'django.contrib.auth',
@@ -48,20 +31,73 @@ INSTALLED_APPS = [
     'django.contrib.sessions',
     'django.contrib.messages',
     'django.contrib.staticfiles',
+    # Third-party apps
     'rest_framework',
     'rest_framework.authtoken',
     'drf_spectacular',
-    'swarm',
+    # Local apps
+    'swarm.apps.SwarmConfig',
 ]
 
+# --- Conditionally add blueprint apps for TESTING ---
+# This ensures the app is known *before* django.setup() is called by pytest-django
+if TESTING:
+    # Add specific apps needed for testing
+    # We know 'university' is needed based on SWARM_BLUEPRINTS in conftest
+    _test_apps_to_add = ['blueprints.university'] # Hardcoding for University tests specifically
+    for app in _test_apps_to_add:
+        if app not in INSTALLED_APPS:
+            # Use insert for potentially better ordering if it matters, otherwise append is fine
+            INSTALLED_APPS.insert(0, app) # Or INSTALLED_APPS.append(app)
+            logging.info(f"Settings [TESTING]: Added '{app}' to INSTALLED_APPS.")
+    # Ensure SWARM_BLUEPRINTS is set if your conftest or other logic relies on it
+    # Note: Setting it here might be redundant if conftest sets it too.
+    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}")
+
+    # Add dynamically discovered apps for non-testing scenarios
+    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 ---
+
+# Ensure INSTALLED_APPS is a list for compatibility
+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',
-    # Add custom middleware to handle async user loading after standard auth
-    'swarm.middleware.AsyncAuthMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'django.middleware.clickjacking.XFrameOptionsMiddleware',
 ]
@@ -71,7 +107,7 @@ ROOT_URLCONF = 'swarm.urls'
 TEMPLATES = [
     {
         'BACKEND': 'django.template.backends.django.DjangoTemplates',
-        'DIRS': [BASE_DIR.parent / 'templates'],
+        'DIRS': [BASE_DIR / 'templates'],
         'APP_DIRS': True,
         'OPTIONS': {
             'context_processors': [
@@ -85,93 +121,105 @@ TEMPLATES = [
 ]
 
 WSGI_APPLICATION = 'swarm.wsgi.application'
-ASGI_APPLICATION = 'swarm.asgi.application'
 
+# Database
+SQLITE_DB_PATH = os.getenv('SQLITE_DB_PATH', BASE_DIR / 'db.sqlite3')
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': os.environ.get('DJANGO_DB_NAME', '/tmp/db.sqlite3'),
-        'TEST': {
-            'NAME': os.environ.get('DJANGO_TEST_DB_NAME', '/tmp/test_db.sqlite3'),
-            'OPTIONS': {
-                'timeout': 20,
-                'init_command': "PRAGMA journal_mode=WAL;",
-            },
-        },
+        'NAME': SQLITE_DB_PATH,
     }
 }
+DJANGO_DATABASE = DATABASES['default']
 
+
+# Password validation
 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',},
+    {'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'},
 ]
 
+
+# Internationalization
 LANGUAGE_CODE = 'en-us'
 TIME_ZONE = 'UTC'
 USE_I18N = True
 USE_TZ = True
 
-STATIC_URL = 'static/'
-STATIC_ROOT = BASE_DIR.parent / 'staticfiles'
-STATICFILES_DIRS = [ BASE_DIR / "swarm" / "static", ]
 
+# Static files
+STATIC_URL = '/static/'
+STATIC_ROOT = BASE_DIR / 'staticfiles'
+STATICFILES_DIRS = [
+    BASE_DIR / 'static',
+    BASE_DIR / 'assets',
+]
+
+# Default primary key field type
 DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
 
+# REST Framework settings
 REST_FRAMEWORK = {
-    'DEFAULT_AUTHENTICATION_CLASSES': [
-        'swarm.auth.StaticTokenAuthentication',
-        'swarm.auth.CustomSessionAuthentication',
-    ],
-    # *** IMPORTANT: Add DEFAULT_PERMISSION_CLASSES ***
-    # If ENABLE_API_AUTH is False, we might want to allow any access for testing.
-    # If ENABLE_API_AUTH is True, we require HasValidTokenOrSession.
-    # We need to set this dynamically based on ENABLE_API_AUTH.
-    # A simple way is to set it here, but a cleaner way might involve middleware
-    # or overriding get_permissions in views. For now, let's adjust this:
-    'DEFAULT_PERMISSION_CLASSES': [
-         # If auth is enabled, require our custom permission
-         'swarm.permissions.HasValidTokenOrSession' if ENABLE_API_AUTH else
-         # Otherwise, allow anyone (useful for dev when token isn't set)
-         'rest_framework.permissions.AllowAny'
-    ],
     '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 managing autonomous agent swarms',
-    'VERSION': '0.2.0',
+    '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 configuration
 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'formatters': {
-        'verbose': { 'format': '[{levelname}] {asctime} - {name}:{lineno} - {message}', 'style': '{', },
-        'simple': { 'format': '[{levelname}] {message}', 'style': '{', },
+         'standard': {
+            'format': '[%(levelname)s] %(asctime)s - %(name)s:%(lineno)d - %(message)s'
+        },
     },
     'handlers': {
-        'console': { 'class': 'logging.StreamHandler', 'formatter': 'verbose', },
+        'console': {
+            'level': 'DEBUG' if DEBUG else 'INFO',
+            'class': 'logging.StreamHandler',
+            'formatter': 'standard',
+        },
     },
     'loggers': {
-        'django': { 'handlers': ['console'], 'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'), 'propagate': False, },
-        'swarm': { 'handlers': ['console'], 'level': os.getenv('SWARM_LOG_LEVEL', 'DEBUG'), 'propagate': False, },
-        'swarm.auth': { 'handlers': ['console'], 'level': 'DEBUG', 'propagate': False, },
-        'swarm.views': { 'handlers': ['console'], 'level': 'DEBUG', 'propagate': False, },
-        'swarm.extensions': { 'handlers': ['console'], 'level': 'DEBUG', 'propagate': False, },
-        'blueprint_django_chat': { 'handlers': ['console'], 'level': 'DEBUG', 'propagate': False, },
-        'print_debug': { 'handlers': ['console'], 'level': 'DEBUG', 'propagate': False, },
+        '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, },
     },
-    'root': { 'handlers': ['console'], 'level': 'WARNING', },
 }
 
+# Authentication backends
+AUTHENTICATION_BACKENDS = [
+    'django.contrib.auth.backends.ModelBackend',
+]
+
+# Login URL
+LOGIN_URL = '/accounts/login/'
+LOGIN_REDIRECT_URL = '/chatbot/'
+
+# Redis settings
 REDIS_HOST = os.getenv('REDIS_HOST', 'localhost')
-REDIS_PORT = int(os.getenv('REDIS_PORT', '6379'))
+REDIS_PORT = int(os.getenv('REDIS_PORT', 6379))
 
-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(',')
+# Adjust DB for testing if TESTING flag is set
+if TESTING:
+     print("Pytest detected: Adjusting settings for testing.")
+     DATABASES['default']['NAME'] = ':memory:'

swarm/types.py

@@ -0,0 +1,91 @@
+from openai.types.chat import ChatCompletionMessage
+from openai.types.chat.chat_completion_message_tool_call import (
+    ChatCompletionMessageToolCall,
+    Function,
+)
+from typing import List, Callable, Union, Optional, Dict, Any
+
+from pydantic import BaseModel, ConfigDict
+
+# AgentFunction = Callable[[], Union[str, "Agent", dict]]
+AgentFunction = Callable[..., Union[str, "Agent", dict]]
+
+class Agent(BaseModel):
+    # model_config = ConfigDict(arbitrary_types_allowed=True)  # Allow non-Pydantic types (for nemo guardrails instance)
+
+    name: str = "Agent"
+    model: str = "default"
+    instructions: Union[str, Callable[[], str]] = "You are a helpful agent."
+    functions: List[AgentFunction] = []
+    resources: List[Dict[str, Any]] = []  # New attribute for static and MCP-discovered resources
+    tool_choice: str = None
+    # parallel_tool_calls: bool = True  # Commented out as in your version
+    parallel_tool_calls: bool = False
+    mcp_servers: Optional[List[str]] = None  # List of MCP server names
+    env_vars: Optional[Dict[str, str]] = None  # Environment variables required
+    response_format: Optional[Dict[str, Any]] = None  # Structured Output
+
+class Response(BaseModel):
+    id: Optional[str] = None  # id needed for REST
+    messages: List = []  # Adjusted to allow any list (flexible for messages)
+    agent: Optional[Agent] = None
+    context_variables: dict = {}
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Automatically generate an ID if not provided
+        if not self.id:
+            import uuid
+            self.id = f"response-{uuid.uuid4()}"
+
+class Result(BaseModel):
+    """
+    Encapsulates the possible return values for an agent function.
+
+    Attributes:
+        value (str): The result value as a string.
+        agent (Agent): The agent instance, if applicable.
+        context_variables (dict): A dictionary of context variables.
+    """
+    value: str = ""
+    agent: Optional[Agent] = None
+    context_variables: dict = {}
+
+class Tool:
+    def __init__(
+        self,
+        name: str,
+        func: Callable,
+        description: str = "",
+        input_schema: Optional[Dict[str, Any]] = None,
+        dynamic: bool = False,
+    ):
+        """
+        Initialize a Tool object.
+
+        :param name: Name of the tool.
+        :param func: The callable associated with this tool.
+        :param description: A brief description of the tool.
+        :param input_schema: Schema defining the inputs the tool accepts.
+        :param dynamic: Whether this tool is dynamically generated.
+        """
+        self.name = name
+        self.func = func
+        self.description = description
+        self.input_schema = input_schema or {}
+        self.dynamic = dynamic
+
+    @property
+    def __name__(self):
+        return self.name
+
+    @property
+    def __code__(self):
+        # Return the __code__ of the actual function, or a mock object if missing
+        return getattr(self.func, "__code__", None)
+
+    def __call__(self, *args, **kwargs):
+        """
+        Make the Tool instance callable.
+        """
+        return self.func(*args, **kwargs)