open-swarm 0.1.1743070217__py3-none-any.whl → 0.1.1743364176__py3-none-any.whl

swarm/llm/chat_completion.py

@@ -8,25 +8,21 @@ tool call repair, and interaction with the OpenAI API. Located in llm/ for LLM-s
 import os
 import json
 import logging
-from typing import List, Optional, Dict, Any, Union, AsyncGenerator # Added AsyncGenerator
+from typing import List, Optional, Dict, Any, Union, AsyncGenerator
 from collections import defaultdict
 
 import asyncio
 from openai import AsyncOpenAI, OpenAIError
-# Make sure ChatCompletionMessage is correctly imported if it's defined elsewhere
-# Assuming it might be part of the base model or a common types module
-# For now, let's assume it's implicitly handled or use a dict directly
-# from ..types import ChatCompletionMessage, Agent # If defined in types
-from ..types import Agent # Import Agent
+from ..types import 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
+# --- REMOVED import: from ..utils.message_sequence import repair_message_payload ---
 
 # Configure module-level logging
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
+# logger.setLevel(logging.DEBUG) # Keep level controlled by main setup
 if not logger.handlers:
     stream_handler = logging.StreamHandler()
     formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
@@ -42,31 +38,15 @@ async def get_chat_completion(
     current_llm_config: Dict[str, Any],
     max_context_tokens: int,
     max_context_messages: int,
-    tools: Optional[List[Dict[str, Any]]] = None, # <-- Added tools parameter
-    tool_choice: Optional[str] = "auto",         # <-- Added tool_choice parameter
+    tools: Optional[List[Dict[str, Any]]] = None,
+    tool_choice: Optional[str] = "auto",
     model_override: Optional[str] = None,
     stream: bool = False,
     debug: bool = False
-) -> Union[Dict[str, Any], AsyncGenerator[Any, None]]: # Adjusted return type hint
+) -> Union[Dict[str, Any], AsyncGenerator[Any, None]]:
     """
     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.
-        tools: Optional list of tools in OpenAI format.
-        tool_choice: Tool choice mode (e.g., "auto", "none").
-        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:
-        Union[Dict[str, Any], AsyncGenerator[Any, None]]: The LLM's response message (as dict) or stream.
+    Relies on openai-agents Runner for actual execution, this might become deprecated.
     """
     if not agent:
         logger.error("Cannot generate chat completion: Agent is None")
@@ -87,7 +67,9 @@ async def get_chat_completion(
     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)
+
+    # --- REMOVED call to repair_message_payload for system message ---
+    messages = [{"role": "system", "content": instructions}]
 
     if not isinstance(history, list):
         logger.error(f"Invalid history type for '{agent.name}': {type(history)}. Expected list.")
@@ -100,15 +82,14 @@ async def get_chat_completion(
             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
-            # Ensure content: None becomes content: "" for API compatibility
             if "content" in msg and msg["content"] is None:
                  msg["content"] = ""
             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
-    # Final content None -> "" check after repair
-    messages = update_null_content(messages)
+    # --- REMOVED call to repair_message_payload after truncation ---
+    messages = update_null_content(messages) # Keep null content update
 
     logger.debug(f"Prepared {len(messages)} messages for '{agent.name}'")
     if debug:
@@ -119,45 +100,42 @@ async def get_chat_completion(
         "messages": messages,
         "stream": stream,
         "temperature": current_llm_config.get("temperature", 0.7),
-        # --- Pass tools and tool_choice ---
         "tools": tools if tools else None,
-        "tool_choice": tool_choice if tools else None, # Only set tool_choice if tools are provided
+        "tool_choice": tool_choice if tools else None,
     }
     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} # Clean None values
+    create_params = {k: v for k, v in create_params.items() if v is not None}
 
     tool_info_log = f", tools_count={len(tools)}" if tools else ", tools=None"
     logger.debug(f"Chat completion params: model='{active_model}', messages_count={len(messages)}, stream={stream}{tool_info_log}, tool_choice={create_params.get('tool_choice')}")
 
     try:
         logger.debug(f"Calling OpenAI API for '{agent.name}' with model='{active_model}'")
-        # Temporary workaround for potential env var conflicts if client doesn't isolate well
         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
+                return completion
 
-            # --- Handle Non-Streaming Response ---
             if completion.choices and len(completion.choices) > 0 and completion.choices[0].message:
                 message_dict = completion.choices[0].message.model_dump(exclude_none=True)
                 log_msg = message_dict.get("content", "No content")[:50] if message_dict.get("content") else "No content"
                 if message_dict.get("tool_calls"): log_msg += f" (+{len(message_dict['tool_calls'])} tool calls)"
                 logger.debug(f"OpenAI completion received for '{agent.name}': {log_msg}...")
-                return message_dict # Return the message dictionary
+                return message_dict
             else:
                 logger.warning(f"No valid message in completion for '{agent.name}'")
-                return {"role": "assistant", "content": "No response generated"} # Return dict
+                return {"role": "assistant", "content": "No response generated"}
         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
-    except Exception as e: # Catch broader errors during API call
+    except Exception as e:
         logger.error(f"Unexpected error during chat completion for '{agent.name}': {e}", exc_info=True)
-        raise # Re-raise
+        raise
 
 
 async def get_chat_completion_message(
@@ -168,28 +146,21 @@ async def get_chat_completion_message(
     current_llm_config: Dict[str, Any],
     max_context_tokens: int,
     max_context_messages: int,
-    tools: Optional[List[Dict[str, Any]]] = None, # <-- Added tools
-    tool_choice: Optional[str] = "auto",        # <-- Added tool_choice
+    tools: Optional[List[Dict[str, Any]]] = None,
+    tool_choice: Optional[str] = "auto",
     model_override: Optional[str] = None,
     stream: bool = False,
     debug: bool = False
-) -> Union[Dict[str, Any], AsyncGenerator[Any, None]]: # Return dict or stream
+) -> Union[Dict[str, Any], AsyncGenerator[Any, None]]:
     """
     Wrapper to retrieve and validate a chat completion message (returns dict or stream).
-
-    Args:
-        Same as get_chat_completion.
-
-    Returns:
-        Union[Dict[str, Any], AsyncGenerator[Any, None]]: Validated LLM response message as dict or the stream.
+    Relies on openai-agents Runner for actual execution, this might become deprecated.
     """
     logger.debug(f"Fetching chat completion message for '{agent.name}'")
     completion_result = await get_chat_completion(
         client, agent, history, context_variables, current_llm_config,
         max_context_tokens, max_context_messages,
-        tools=tools, tool_choice=tool_choice, # Pass through
+        tools=tools, tool_choice=tool_choice,
         model_override=model_override, stream=stream, debug=debug
     )
-    # If streaming, completion_result is already the generator
-    # If not streaming, it's the message dictionary
     return completion_result

swarm/management/commands/runserver.py

@@ -0,0 +1,58 @@
+import os
+import logging
+from django.core.management.commands.runserver import Command as RunserverCommand
+from django.conf import settings
+from dotenv import load_dotenv
+from pathlib import Path
+
+# Load .env from project root relative to this file's location
+BASE_DIR = Path(__file__).resolve().parent.parent.parent.parent.parent
+# Check if .env exists before trying to load
+dotenv_path = BASE_DIR / '.env'
+if dotenv_path.is_file():
+    load_dotenv(dotenv_path=dotenv_path)
+else:
+    # Optionally log if .env is missing, but don't require it
+    # logger = logging.getLogger(__name__) # Get logger if needed here
+    # logger.debug(".env file not found in project root, relying solely on environment variables.")
+    pass
+
+
+logger = logging.getLogger(__name__) # Get logger for command messages
+
+class Command(RunserverCommand):
+    help = 'Starts a lightweight Web server for development, with an option to enable Swarm API authentication.'
+
+    def add_arguments(self, parser):
+        super().add_arguments(parser)
+        parser.add_argument(
+            '--enable-auth',
+            action='store_true',
+            dest='enable_auth',
+            help='Enable Swarm API Key authentication using API_AUTH_TOKEN from environment/.env.', # Updated help text
+        )
+
+    def handle(self, *args, **options):
+        enable_auth_flag = options.get('enable_auth', False)
+        api_key = None # Keep internal variable name simple
+
+        if enable_auth_flag:
+            settings.ENABLE_API_AUTH = True # Override setting
+            # *** Use API_AUTH_TOKEN from environment ***
+            api_key = os.getenv('API_AUTH_TOKEN')
+            if api_key:
+                settings.SWARM_API_KEY = api_key # Store the key in settings
+                logger.info("Swarm API authentication ENABLED via --enable-auth flag. API_AUTH_TOKEN found.")
+            else:
+                settings.SWARM_API_KEY = None # Ensure it's None if not found
+                logger.warning("Swarm API authentication ENABLED via --enable-auth flag, but API_AUTH_TOKEN not found in environment/.env. API will allow anonymous access if session auth fails.")
+        else:
+            # Keep defaults from settings.py (ENABLE_API_AUTH=False, SWARM_API_KEY=None)
+            # Ensure SWARM_API_KEY is explicitly None if auth is disabled
+            settings.ENABLE_API_AUTH = False
+            settings.SWARM_API_KEY = None
+            logger.info("Swarm API authentication DISABLED (run with --enable-auth and set API_AUTH_TOKEN to activate).")
+
+        # Call the original runserver command handler
+        super().handle(*args, **options)
+

swarm/permissions.py

@@ -0,0 +1,38 @@
+import logging
+from rest_framework.permissions import BasePermission
+from django.conf import settings
+from swarm.auth import StaticTokenAuthentication # Import for type checking
+
+logger = logging.getLogger(__name__)
+
+class HasValidTokenOrSession(BasePermission):
+    """
+    Allows access if the user is authenticated via a valid session
+    OR if a valid static API token was provided (indicated by request.auth).
+    """
+
+    def has_permission(self, request, view):
+        # Check if standard Django user authentication succeeded (Session)
+        # This user comes from AuthenticationMiddleware + CustomSessionAuthentication
+        is_session_authenticated = request.user and request.user.is_authenticated
+        if is_session_authenticated:
+            logger.debug("[Permission] Access granted via authenticated session user.")
+            return True
+
+        # Check if StaticTokenAuthentication succeeded.
+        # We modified StaticTokenAuthentication to return (AnonymousUser(), token)
+        # DRF populates request.auth with the second element of the tuple (the token).
+        # We also check the authenticator type for robustness.
+        is_static_token_auth = (
+            request.successful_authenticator and
+            isinstance(request.successful_authenticator, StaticTokenAuthentication) and
+            request.auth is not None # Check if request.auth (the token) was set
+        )
+
+        if is_static_token_auth:
+             logger.debug("[Permission] Access granted via valid static API token.")
+             return True
+
+        logger.debug("[Permission] Access denied. No valid session or static token found.")
+        return False
+

swarm/serializers.py

@@ -1,12 +1,103 @@
 from rest_framework import serializers
-from swarm.models import ChatMessage, ChatConversation
+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
 
 class ChatMessageSerializer(serializers.ModelSerializer):
     class Meta:
         model = ChatMessage
         fields = '__all__'
 
-class ChatConversationSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ChatConversation
-        fields = '__all__'