open-swarm 0.1.1743070217__py3-none-any.whl

swarm/utils/message_sequence.py

@@ -0,0 +1,173 @@
+"""
+Utilities for validating and repairing message sequences.
+"""
+
+from typing import List, Dict, Any
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+try:
+    from .message_utils import filter_duplicate_system_messages
+except ImportError:
+    try: from swarm.utils.message_utils import filter_duplicate_system_messages
+    except ImportError:
+        logger.warning("filter_duplicate_system_messages not found. Using dummy.")
+        def filter_duplicate_system_messages(messages):
+            output = []; system_found = False
+            for msg in messages:
+                if isinstance(msg, dict) and msg.get("role") == "system":
+                    if not system_found: output.append(msg); system_found = True
+                # *** Fix in dummy: Append non-dicts too if needed, or filter here?
+                # Let's assume the filter should focus only on system duplicates for now.
+                elif not (isinstance(msg, dict) and msg.get("role") == "system"):
+                     output.append(msg)
+            return output
+
+def validate_message_sequence(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Ensure tool messages correspond to valid tool calls in the sequence.
+    Also filters out non-dictionary items.
+    """
+    if not isinstance(messages, list):
+        logger.error(f"Invalid messages type for validation: {type(messages)}. Returning [].")
+        return []
+    logger.debug(f"Validating message sequence with {len(messages)} messages")
+
+    # *** FIX: Filter non-dicts FIRST ***
+    dict_messages = [msg for msg in messages if isinstance(msg, dict)]
+    if len(dict_messages) < len(messages):
+        logger.warning(f"Removed {len(messages) - len(dict_messages)} non-dictionary items during validation.")
+
+    try:
+        # *** FIX: Operate ONLY on dict_messages ***
+        valid_tool_call_ids = {
+            tc["id"]
+            for msg in dict_messages # Use filtered list
+            if msg.get("role") == "assistant" and isinstance(msg.get("tool_calls"), list)
+            for tc in msg.get("tool_calls", [])
+            if isinstance(tc, dict) and "id" in tc
+        }
+    except Exception as e:
+        logger.error(f"Error building valid_tool_call_ids: {e}", exc_info=True)
+        valid_tool_call_ids = set()
+
+    validated_messages = []
+    # *** FIX: Operate ONLY on dict_messages ***
+    for msg in dict_messages:
+        role = msg.get("role")
+        if role == "tool":
+            tool_call_id = msg.get("tool_call_id")
+            if tool_call_id in valid_tool_call_ids:
+                validated_messages.append(msg)
+            else:
+                logger.warning(f"Removing orphan tool message: {str(msg)[:100]}")
+        # *** FIX: Add basic check for other essential roles before appending ***
+        elif role in ["system", "user", "assistant"]:
+             # We could add more role-specific checks here if needed (like _is_valid_message)
+             # For now, just ensure it's one of the expected roles.
+             validated_messages.append(msg)
+        else:
+             logger.warning(f"Removing message with unknown/missing role during validation: {str(msg)[:100]}")
+
+
+    return validated_messages
+
+def repair_message_payload(messages: List[Dict[str, Any]], debug: bool = False) -> List[Dict[str, Any]]:
+    """
+    Repair the message sequence by potentially inserting dummy messages for missing pairs.
+    Filters invalid messages and orphan tools first.
+    """
+    if not isinstance(messages, list):
+        logger.error(f"Invalid messages type for repair: {type(messages)}. Returning [].")
+        return []
+    logger.debug(f"Repairing message payload with {len(messages)} messages")
+
+    try:
+        messages_no_dup_sys = filter_duplicate_system_messages(messages)
+    except Exception as e:
+        logger.error(f"Error during filter_duplicate_system_messages: {e}. Proceeding.")
+        messages_no_dup_sys = messages
+
+    # Run validation which now correctly handles non-dicts first
+    repaired_validated = validate_message_sequence(messages_no_dup_sys)
+    logger.debug(f"After validation, {len(repaired_validated)} messages remain for repair loop.")
+
+
+    final_sequence = []
+    i = 0
+    processed_tool_ids = set()
+
+    while i < len(repaired_validated):
+        msg = repaired_validated[i]
+        role = msg.get("role") # Should always be a valid dict here
+
+        if role == "assistant" and isinstance(msg.get("tool_calls"), list) and msg["tool_calls"]:
+            logger.debug(f"Repair Loop: Processing assistant at index {i}")
+            final_sequence.append(msg)
+            tool_calls = msg["tool_calls"]
+            expected_ids = {tc.get("id") for tc in tool_calls if isinstance(tc, dict) and tc.get("id")}
+
+            j = i + 1
+            found_ids_for_this_call = set()
+            logger.debug(f"  Looking ahead for tools from index {j}. Expected IDs: {expected_ids}")
+            while j < len(repaired_validated) and repaired_validated[j].get("role") == "tool":
+                tool_msg = repaired_validated[j]
+                tool_call_id = tool_msg.get("tool_call_id")
+                logger.debug(f"  Checking tool at index {j} (ID: {tool_call_id})")
+                if tool_call_id in expected_ids:
+                    final_sequence.append(tool_msg)
+                    found_ids_for_this_call.add(tool_call_id)
+                    processed_tool_ids.add(tool_call_id)
+                    logger.debug(f"    Found and appended expected tool response.")
+                else:
+                    logger.debug(f"    Tool ID does not match current assistant call. Stopping lookahead.")
+                    break
+                j += 1
+
+            missing_ids_for_this_call = expected_ids - found_ids_for_this_call
+            if missing_ids_for_this_call:
+                logger.warning(f"  Missing {len(missing_ids_for_this_call)} tool responses for assistant call {i}. IDs: {missing_ids_for_this_call}. Inserting dummies.")
+                for missing_id in missing_ids_for_this_call:
+                    tool_name = "unknown_tool"
+                    for tc in tool_calls:
+                        if isinstance(tc, dict) and tc.get("id") == missing_id:
+                           tool_name = tc.get("function", {}).get("name", "unknown_tool"); break
+                    dummy_tool = {"role": "tool", "tool_call_id": missing_id, "name": tool_name, "content": f"Error: Tool response for {tool_name} missing."} # Use name field like T1_RESP
+                    logger.debug(f"    Appending dummy tool: {dummy_tool}")
+                    final_sequence.append(dummy_tool)
+                    processed_tool_ids.add(missing_id)
+            # else:
+                 # logger.debug(f"  All tool responses found for assistant call {i}.")
+
+            i = j # Move main index past assistant and its processed tools
+
+        elif role == "tool":
+            # This case handles tools that were *not* removed by validation (meaning their ID exists somewhere)
+            # but were not found immediately after their corresponding assistant call by the lookahead above.
+            # OR tools whose assistant call was completely missing/invalid.
+            tool_call_id = msg.get("tool_call_id")
+            if tool_call_id in processed_tool_ids:
+                 logger.debug(f"Repair Loop: Skipping tool msg at index {i} (id: {tool_call_id}), already processed.")
+                 i += 1
+            else:
+                # Insert a dummy assistant call before it
+                logger.warning(f"Repair Loop: Found tool msg {i} (id: {tool_call_id}) without preceding assistant. Inserting dummy assistant.")
+                tool_name = msg.get("name", "unknown_tool") # Get tool name from tool message itself
+                dummy_assistant = {"role": "assistant", "content": None, "tool_calls": [{"id": tool_call_id, "type": "function", "function": {"name": tool_name, "arguments": "{}"}}]}
+                final_sequence.append(dummy_assistant)
+                final_sequence.append(msg)
+                processed_tool_ids.add(tool_call_id)
+                i += 1
+        else:
+            # System or User message
+            logger.debug(f"Repair Loop: Processing {role} at index {i}")
+            final_sequence.append(msg)
+            i += 1
+
+    if debug: logger.debug(f"Repaired payload: {json.dumps(final_sequence, indent=2, default=str)}")
+    elif len(messages) != len(final_sequence): # Log if changes were made (even without full debug)
+        logger.info(f"Repair changed message count from {len(messages)} to {len(final_sequence)}")
+
+    return final_sequence

swarm/utils/message_utils.py

@@ -0,0 +1,95 @@
+"""
+Utility functions for processing chat messages in the Swarm framework.
+"""
+
+import logging
+import json # Added import
+
+logger = logging.getLogger(__name__)
+
+def filter_duplicate_system_messages(messages):
+    """Remove duplicate system messages, keeping only the first occurrence."""
+    filtered = []
+    system_found = False
+    for msg in messages:
+         # Ensure msg is a dictionary and has a 'role' key
+        if isinstance(msg, dict) and "role" in msg:
+            if msg["role"] == "system":
+                if not system_found:
+                    filtered.append(msg)
+                    system_found = True
+                # Else: skip subsequent system messages
+            else:
+                filtered.append(msg)
+        elif isinstance(msg, dict): # Handle dicts without 'role' if necessary
+             # Keep dicts without roles based on previous behavior? Or filter?
+             # Let's keep them for now, consistent with test_filter_mixed_valid_invalid expectation
+             logger.warning(f"Message dictionary missing 'role' key: {msg}")
+             filtered.append(msg)
+        else:
+             logger.warning(f"Skipping non-dictionary item in messages list: {type(msg)}")
+             # Skip non-dict items
+
+    return filtered
+
+def filter_messages(messages):
+    """Filter out messages with empty/None content or only whitespace, unless they have tool_calls."""
+    result = []
+    if not isinstance(messages, list):
+         logger.error(f"filter_messages received non-list input: {type(messages)}")
+         return []
+
+    for msg in messages:
+        if not isinstance(msg, dict):
+            logger.warning(f"Skipping non-dictionary item in messages list: {type(msg)}")
+            continue
+
+        content = msg.get('content')
+        tool_calls = msg.get('tool_calls')
+
+        # Keep message if it has non-whitespace content OR has non-empty tool_calls
+        has_valid_content = content is not None and isinstance(content, str) and content.strip() != ""
+        has_tool_calls = tool_calls is not None and isinstance(tool_calls, list) and len(tool_calls) > 0
+
+        if has_valid_content or has_tool_calls:
+            result.append(msg)
+        else:
+             logger.debug(f"Filtering out message due to empty/None/whitespace content and no tool calls: {msg}")
+
+    return result
+
+
+def update_null_content(input_data):
+    """
+    Replace 'content: None' with 'content: ""' in a message dictionary or list of dictionaries.
+    Does NOT add the 'content' key if it's missing.
+    """
+    if isinstance(input_data, dict):
+        # Process a single message dictionary
+        # Check if 'content' key exists AND its value is None
+        if 'content' in input_data and input_data['content'] is None:
+            input_data['content'] = ""
+            logger.debug(f"Updated 'content: None' to 'content: \"\"' in dict: {input_data.get('role', 'N/A')}")
+        return input_data
+    elif isinstance(input_data, list):
+        # Process a list of messages (modify in-place or create new list)
+        # Creating new list to avoid modifying original list unexpectedly
+        processed_list = []
+        for msg in input_data:
+            if isinstance(msg, dict):
+                 # Create a copy to modify
+                 new_msg = msg.copy()
+                 if 'content' in new_msg and new_msg['content'] is None:
+                     new_msg['content'] = ""
+                     logger.debug(f"Updated 'content: None' to 'content: \"\"' in list item: {new_msg.get('role', 'N/A')}")
+                 processed_list.append(new_msg)
+            else:
+                 logger.warning(f"Skipping non-dictionary item during null content update: {type(msg)}")
+                 processed_list.append(msg) # Append non-dict item unchanged
+        return processed_list
+    else:
+         # Return other types unchanged
+         logger.warning(f"update_null_content received unexpected type: {type(input_data)}. Returning unchanged.")
+         return input_data
+
+# redact_sensitive_data is now centralized in swarm.utils.redact

swarm/utils/redact.py

@@ -0,0 +1,68 @@
+"""
+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

swarm/views/__init__.py

@@ -0,0 +1,41 @@
+"""
+Initializes the views package and exposes key view modules and viewsets.
+"""
+# Import the view modules to make them accessible via swarm.views.*
+# Use try-except for robustness during development/refactoring
+try:
+    from . import core_views
+except ImportError as e:
+    print(f"Warning: Could not import swarm.views.core_views: {e}")
+    core_views = None
+
+try:
+    from . import chat_views
+except ImportError as e:
+    print(f"Warning: Could not import swarm.views.chat_views: {e}")
+    chat_views = None
+
+try:
+    from . import model_views
+except ImportError as e:
+    print(f"Warning: Could not import swarm.views.model_views: {e}")
+    model_views = None
+
+try:
+    from . import message_views
+    from .message_views import ChatMessageViewSet
+except ImportError as e:
+    print(f"Warning: Could not import swarm.views.message_views: {e}")
+    message_views = None
+    ChatMessageViewSet = None # Ensure it's None if import fails
+
+try:
+    from . import utils
+except ImportError as e:
+    print(f"Warning: Could not import swarm.views.utils: {e}")
+    utils = None
+
+
+# Expose only successfully imported components
+__all__ = [name for name, obj in globals().items() if obj is not None and not name.startswith('_')]
+

swarm/views/api_views.py

@@ -0,0 +1,46 @@
+"""
+API-specific views and viewsets for Open Swarm MCP Core.
+"""
+from rest_framework.viewsets import ModelViewSet
+from rest_framework.permissions import AllowAny
+from drf_spectacular.views import SpectacularAPIView as BaseSpectacularAPIView
+from drf_spectacular.utils import extend_schema
+from swarm.utils.logger_setup import setup_logger
+from swarm.models import ChatMessage
+from swarm.serializers import ChatMessageSerializer
+
+logger = setup_logger(__name__)
+
+class HiddenSpectacularAPIView(BaseSpectacularAPIView):
+    exclude_from_schema = True
+
+class ChatMessageViewSet(ModelViewSet):
+    """API viewset for managing chat messages."""
+    authentication_classes = []
+    permission_classes = [AllowAny]
+    queryset = ChatMessage.objects.all()
+    serializer_class = ChatMessageSerializer
+
+    @extend_schema(summary="List all chat messages")
+    def list(self, request, *args, **kwargs):
+        return super().list(request, *args, **kwargs)
+
+    @extend_schema(summary="Retrieve a chat message by its unique id")
+    def retrieve(self, request, *args, **kwargs):
+        return super().retrieve(request, *args, **kwargs)
+
+    @extend_schema(summary="Create a new chat message")
+    def create(self, request, *args, **kwargs):
+        return super().create(request, *args, **kwargs)
+
+    @extend_schema(summary="Update an existing chat message")
+    def update(self, request, *args, **kwargs):
+        return super().update(request, *args, **kwargs)
+
+    @extend_schema(summary="Partially update a chat message")
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    @extend_schema(summary="Delete a chat message by its unique id")
+    def destroy(self, request, *args, **kwargs):
+        return super().destroy(request, *args, **kwargs)

swarm/views/chat_views.py

@@ -0,0 +1,76 @@
+"""
+Chat-related views for Open Swarm MCP Core.
+"""
+import asyncio
+import logging
+import json
+from django.views.decorators.csrf import csrf_exempt
+from rest_framework.response import Response
+from rest_framework.decorators import api_view, authentication_classes, permission_classes
+from rest_framework.permissions import IsAuthenticated
+from swarm.auth import EnvOrTokenAuthentication
+from swarm.utils.logger_setup import setup_logger
+from swarm.views import utils as view_utils
+from swarm.extensions.config.config_loader import config
+from swarm.settings import Settings
+
+logger = setup_logger(__name__)
+
+# Removed _run_async_in_sync helper
+
+@api_view(['POST'])
+@csrf_exempt
+@authentication_classes([EnvOrTokenAuthentication])
+@permission_classes([IsAuthenticated])
+def chat_completions(request): # Sync view
+    """Handle chat completion requests via POST."""
+    if request.method != "POST":
+        return Response({"error": "Method not allowed. Use POST."}, status=405)
+    logger.info(f"Authenticated User: {request.user}")
+
+    parse_result = view_utils.parse_chat_request(request)
+    if isinstance(parse_result, Response): return parse_result
+
+    body, model, messages, context_vars, conversation_id, tool_call_id = parse_result
+    model_type = "llm" if model in config.get('llm', {}) and config.get('llm', {}).get(model, {}).get("passthrough") else "blueprint"
+    logger.info(f"Identified model type: {model_type} for model: {model}")
+
+    if model_type == "llm":
+         return Response({"error": f"LLM passthrough for model '{model}' not implemented."}, status=501)
+
+    try:
+        blueprint_instance = view_utils.get_blueprint_instance(model, context_vars)
+        messages_extended = view_utils.load_conversation_history(conversation_id, messages, tool_call_id)
+
+        # Try running the async function using asyncio.run()
+        # This might fail in test environments with existing loops.
+        try:
+            logger.debug("Attempting asyncio.run(run_conversation)...")
+            response_obj, updated_context = asyncio.run(
+                view_utils.run_conversation(blueprint_instance, messages_extended, context_vars)
+            )
+            logger.debug("asyncio.run(run_conversation) completed.")
+        except RuntimeError as e:
+             # Catch potential nested loop errors specifically from asyncio.run()
+             logger.error(f"Asyncio run error: {e}", exc_info=True)
+             # Return a 500 error, as the async call couldn't be completed
+             return Response({"error": f"Server execution error: {str(e)}"}, status=500)
+
+
+        serialized = view_utils.serialize_swarm_response(response_obj, model, updated_context)
+
+        if conversation_id:
+            serialized["conversation_id"] = conversation_id
+            view_utils.store_conversation_history(conversation_id, messages_extended, response_obj)
+
+        return Response(serialized, status=200)
+
+    except FileNotFoundError as e:
+         logger.warning(f"Blueprint not found for model '{model}': {e}")
+         return Response({"error": f"Blueprint not found: {model}"}, status=404)
+    # Catch other exceptions, including the potential RuntimeError from above
+    except Exception as e:
+        logger.error(f"Error during execution for model '{model}': {e}", exc_info=True)
+        error_msg = str(e) if Settings().debug else "An internal error occurred."
+        return Response({"error": f"Error during execution: {error_msg}"}, status=500)
+

swarm/views/core_views.py

@@ -0,0 +1,118 @@
+"""
+Core/UI related views for the Swarm framework.
+"""
+import os
+import json
+import logging
+from pathlib import Path
+
+from django.shortcuts import render, redirect
+from django.http import JsonResponse, HttpResponse
+from django.conf import settings
+from django.views.decorators.csrf import csrf_exempt
+from django.contrib.auth import authenticate, login
+
+# Assuming blueprint discovery happens elsewhere and results are available if needed
+# from .utils import blueprints_metadata # Or however metadata is accessed
+from swarm.extensions.config.config_loader import load_server_config # Import if needed
+
+logger = logging.getLogger(__name__)
+
+# Placeholder for blueprint metadata if needed by index
+# In a real app, this might be loaded dynamically or passed via context
+try:
+    # Attempt to import the discovery function if views need dynamic data
+    from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
+    # Note: Calling discover_blueprints here might be too early or cause issues.
+    # It's often better handled in specific views that need it (like list_models)
+    # or passed via Django context processors.
+    # For now, provide an empty dict as fallback.
+    try:
+        # Use settings.BLUEPRINTS_DIR which should be configured
+        blueprints_metadata = discover_blueprints(directories=[str(settings.BLUEPRINTS_DIR)])
+    except Exception:
+        blueprints_metadata = {}
+except ImportError:
+    blueprints_metadata = {}
+
+
+@csrf_exempt
+def index(request):
+    """Render the main index page with blueprint options."""
+    logger.debug("Rendering index page")
+    # Get blueprint names from the potentially loaded metadata
+    blueprint_names_list = list(blueprints_metadata.keys())
+    context = {
+        "dark_mode": request.session.get('dark_mode', True),
+        "enable_admin": os.getenv("ENABLE_ADMIN", "false").lower() in ("true", "1", "t"),
+        "blueprints": blueprint_names_list # Pass the list of names
+    }
+    return render(request, "index.html", context)
+
+DEFAULT_CONFIG = {
+    "llm": {
+        "default": {
+            "provider": "openai",
+            "model": "gpt-4o", # Example fallback model
+            "base_url": "https://api.openai.com/v1",
+            "api_key": "",
+            "temperature": 0.3
+        }
+    },
+     "blueprints": {},
+     "mcpServers": {}
+}
+
+def serve_swarm_config(request):
+    """Serve the swarm configuration file as JSON."""
+    try:
+        # Use load_server_config which handles finding the file
+        config_data = load_server_config()
+        return JsonResponse(config_data)
+    except (FileNotFoundError, ValueError, Exception) as e:
+        logger.error(f"Error serving swarm_config.json: {e}. Serving default.")
+        # Return a default config on error
+        return JsonResponse(DEFAULT_CONFIG, status=500)
+
+
+@csrf_exempt
+def custom_login(request):
+    """Handle custom login at /accounts/login/, redirecting to 'next' URL on success."""
+    from django.contrib.auth.models import User # Import here to avoid potential early init issues
+    if request.method == "POST":
+        username = request.POST.get("username")
+        password = request.POST.get("password")
+        user = authenticate(request, username=username, password=password)
+        if user is not None:
+            login(request, user)
+            next_url = request.GET.get("next", getattr(settings, 'LOGIN_REDIRECT_URL', '/')) # Use setting or fallback
+            logger.info(f"User '{username}' logged in successfully. Redirecting to {next_url}")
+            return redirect(next_url)
+        else:
+            # If ENABLE_API_AUTH is false, auto-login as testuser (for dev/test convenience)
+            enable_auth = os.getenv("ENABLE_API_AUTH", "true").lower() in ("true", "1", "t") # Default to TRUE
+            if not enable_auth:
+                try:
+                    # Ensure test user exists and has a known password
+                    user, created = User.objects.get_or_create(username="testuser")
+                    if created or not user.has_usable_password():
+                         user.set_password("testpass") # Set a default password
+                         user.save()
+
+                    if user.check_password("testpass"): # Check against the known password
+                        login(request, user)
+                        next_url = request.GET.get("next", getattr(settings, 'LOGIN_REDIRECT_URL', '/'))
+                        logger.info(f"Auto-logged in as 'testuser' since ENABLE_API_AUTH is false")
+                        return redirect(next_url)
+                    else:
+                         logger.warning("Auto-login failed: 'testuser' exists but password incorrect.")
+
+                except Exception as auto_login_err:
+                    logger.error(f"Error during testuser auto-login attempt: {auto_login_err}")
+            # If authentication failed (and auto-login didn't happen or failed)
+            logger.warning(f"Login failed for user '{username}'.")
+            return render(request, "account/login.html", {"error": "Invalid credentials"})
+    # If GET request
+    return render(request, "account/login.html")
+
+# Add any other views that were originally in the main views.py if needed

swarm/views/message_views.py

@@ -0,0 +1,40 @@
+"""
+Views related to Chat Messages.
+"""
+from rest_framework.viewsets import ModelViewSet
+from rest_framework.permissions import AllowAny
+from drf_spectacular.utils import extend_schema
+
+from swarm.models import ChatMessage
+from swarm.serializers import ChatMessageSerializer
+
+class ChatMessageViewSet(ModelViewSet):
+    """API viewset for managing chat messages."""
+    authentication_classes = []
+    permission_classes = [AllowAny]
+    queryset = ChatMessage.objects.all().order_by('-timestamp') # Order by timestamp descending
+    serializer_class = ChatMessageSerializer
+
+    @extend_schema(summary="List all chat messages")
+    def list(self, request, *args, **kwargs):
+        return super().list(request, *args, **kwargs)
+
+    @extend_schema(summary="Retrieve a chat message by its unique id")
+    def retrieve(self, request, *args, **kwargs):
+        return super().retrieve(request, *args, **kwargs)
+
+    @extend_schema(summary="Create a new chat message")
+    def create(self, request, *args, **kwargs):
+        return super().create(request, *args, **kwargs)
+
+    @extend_schema(summary="Update an existing chat message")
+    def update(self, request, *args, **kwargs):
+        return super().update(request, *args, **kwargs)
+
+    @extend_schema(summary="Partially update a chat message")
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    @extend_schema(summary="Delete a chat message by its unique id")
+    def destroy(self, request, *args, **kwargs):
+        return super().destroy(request, *args, **kwargs)