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

swarm/llm/chat_completion.py

@@ -8,16 +8,12 @@ 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
 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 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
@@ -42,12 +38,10 @@ 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
     model_override: Optional[str] = None,
     stream: bool = False,
     debug: bool = False
-) -> Union[Dict[str, Any], AsyncGenerator[Any, None]]: # Adjusted return type hint
+) -> ChatCompletionMessage:
     """
     Retrieve a chat completion from the LLM for the given agent and history.
 
@@ -59,14 +53,12 @@ async def get_chat_completion(
         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.
+        ChatCompletionMessage: The LLM's response message.
     """
     if not agent:
         logger.error("Cannot generate chat completion: Agent is None")
@@ -100,15 +92,10 @@ 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)
 
     logger.debug(f"Prepared {len(messages)} messages for '{agent.name}'")
     if debug:
@@ -119,45 +106,32 @@ 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
     }
     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
-
-    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')}")
+    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}'")
-        # 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
-
-            # --- Handle Non-Streaming Response ---
+                return completion  # Return stream object directly
             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)"
+                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 message_dict # Return the message dictionary
+                return completion.choices[0].message
             else:
                 logger.warning(f"No valid message in completion for '{agent.name}'")
-                return {"role": "assistant", "content": "No response generated"} # Return dict
+                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
-    except Exception as e: # Catch broader errors during API call
-        logger.error(f"Unexpected error during chat completion for '{agent.name}': {e}", exc_info=True)
-        raise # Re-raise
 
 
 async def get_chat_completion_message(
@@ -168,28 +142,25 @@ 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
     model_override: Optional[str] = None,
     stream: bool = False,
     debug: bool = False
-) -> Union[Dict[str, Any], AsyncGenerator[Any, None]]: # Return dict or stream
+) -> ChatCompletionMessage:
     """
-    Wrapper to retrieve and validate a chat completion message (returns dict or stream).
+    Wrapper to retrieve and validate a chat completion message.
 
     Args:
         Same as get_chat_completion.
 
     Returns:
-        Union[Dict[str, Any], AsyncGenerator[Any, None]]: Validated LLM response message as dict or the stream.
+        ChatCompletionMessage: Validated LLM response message.
     """
     logger.debug(f"Fetching chat completion message for '{agent.name}'")
-    completion_result = await get_chat_completion(
+    completion = 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
-        model_override=model_override, stream=stream, debug=debug
+        max_context_tokens, max_context_messages, model_override, stream, debug
     )
-    # If streaming, completion_result is already the generator
-    # If not streaming, it's the message dictionary
-    return completion_result
+    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/settings.py

@@ -1,29 +1,11 @@
 """
 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 ---
+import logging
 
 # Build paths inside the project like this: BASE_DIR / 'subdir'.
 BASE_DIR = Path(__file__).resolve().parent.parent
@@ -38,8 +20,7 @@ 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
+DEBUG = os.getenv('DEBUG', 'True') == 'True'
 ALLOWED_HOSTS = os.getenv('DJANGO_ALLOWED_HOSTS', '*').split(',')
 
 # --- Application definition ---
@@ -58,47 +39,59 @@ INSTALLED_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)
+# --- 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',
@@ -129,10 +122,18 @@ TEMPLATES = [
 
 WSGI_APPLICATION = 'swarm.wsgi.application'
 
+# Database
 SQLITE_DB_PATH = os.getenv('SQLITE_DB_PATH', BASE_DIR / 'db.sqlite3')
-DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': SQLITE_DB_PATH } }
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        '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'},
@@ -140,13 +141,26 @@ AUTH_PASSWORD_VALIDATORS = [
     {'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' ]
+# Internationalization
+LANGUAGE_CODE = 'en-us'
+TIME_ZONE = 'UTC'
+USE_I18N = True
+USE_TZ = True
+
 
+# 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_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',
     'DEFAULT_AUTHENTICATION_CLASSES': (
@@ -154,7 +168,9 @@ REST_FRAMEWORK = {
         'rest_framework.authentication.TokenAuthentication',
         'rest_framework.authentication.SessionAuthentication',
     ),
-    'DEFAULT_PERMISSION_CLASSES': ('rest_framework.permissions.IsAuthenticated',)
+    'DEFAULT_PERMISSION_CLASSES': (
+       'rest_framework.permissions.IsAuthenticated',
+    )
 }
 
 SPECTACULAR_SETTINGS = {
@@ -165,10 +181,22 @@ SPECTACULAR_SETTINGS = {
     'SERVE_PERMISSIONS': ['rest_framework.permissions.AllowAny'],
 }
 
+# Logging configuration
 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', }, },
+    '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, },
@@ -178,12 +206,20 @@ LOGGING = {
     },
 }
 
-AUTHENTICATION_BACKENDS = ['django.contrib.auth.backends.ModelBackend']
-LOGIN_URL = '/accounts/login/'; LOGIN_REDIRECT_URL = '/chatbot/'
+# 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))
 
+# 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)

swarm/views/chat_views.py

@@ -1,76 +1,83 @@
 """
 Chat-related views for Open Swarm MCP Core.
 """
-import asyncio
-import logging
-import json
+import asyncio # Import asyncio
 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
+# Import utils but rename to avoid conflict if this module grows
 from swarm.views import utils as view_utils
-from swarm.extensions.config.config_loader import config
-from swarm.settings import Settings
+# from swarm.views.utils import parse_chat_request, serialize_swarm_response, get_blueprint_instance
+# from swarm.views.utils import load_conversation_history, store_conversation_history, run_conversation
+# from swarm.views.utils import config, llm_config  # Import from utils
 
 logger = setup_logger(__name__)
 
-# Removed _run_async_in_sync helper
-
+# Revert to standard sync def
 @api_view(['POST'])
 @csrf_exempt
 @authentication_classes([EnvOrTokenAuthentication])
 @permission_classes([IsAuthenticated])
-def chat_completions(request): # Sync view
+def chat_completions(request): # Mark as sync again
     """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}")
 
+    # Use functions from view_utils
     parse_result = view_utils.parse_chat_request(request)
-    if isinstance(parse_result, Response): return parse_result
+    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"
+    # Use llm_config loaded in utils
+    model_type = "llm" if model in view_utils.llm_config and view_utils.llm_config[model].get("passthrough") else "blueprint"
     logger.info(f"Identified model type: {model_type} for model: {model}")
 
+    # --- Handle LLM Passthrough directly ---
     if model_type == "llm":
+         logger.warning(f"LLM Passthrough requested for model '{model}'. This is not yet fully implemented in this view.")
+         # TODO: Implement direct call to Swarm core or LLM client for passthrough
          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)
+    # --- Handle Blueprint ---
+    blueprint_instance = view_utils.get_blueprint_instance(model, context_vars)
+    if isinstance(blueprint_instance, Response): # Handle error response from get_blueprint_instance
+        return blueprint_instance
+    if blueprint_instance is None: # Handle case where get_blueprint_instance signaled non-blueprint
+         return Response({"error": f"Model '{model}' is not a loadable blueprint."}, status=404)
+
+
+    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:
+        # Use asyncio.run() to call the async run_conversation function
+        # This blocks the sync view until the async operation completes.
         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)
-
+            if "cannot be called from a running event loop" in str(e):
+                 logger.error("Detected nested asyncio.run call. This can happen in certain test/server setups.")
+                 # If already in a loop (e.g., certain test runners or ASGI servers),
+                 # you might need a different way to run the async code, like ensure_future
+                 # or adapting the server setup. For now, return an error.
+                 return Response({"error": "Server configuration error: Nested event loop detected."}, status=500)
+            else:
+                 raise e # Reraise other RuntimeErrors
 
         serialized = view_utils.serialize_swarm_response(response_obj, model, updated_context)
 
         if conversation_id:
             serialized["conversation_id"] = conversation_id
+            # Storing history can remain synchronous for now unless it becomes a bottleneck
             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)
-
+        logger.error(f"Error during execution: {e}", exc_info=True)
+        return Response({"error": f"Error during execution: {str(e)}"}, status=500)

swarm/views/utils.py

@@ -2,7 +2,6 @@
 Utility functions for Swarm views.
 """
 import json
-from swarm.types import ChatMessage
 import uuid
 import time
 import os
@@ -358,8 +357,7 @@ def store_conversation_history(conversation_id: str, full_history: List[dict], r
         # Add only messages not already in full_history (prevent duplicates if run_conversation includes input)
         last_stored_content = json.dumps(history_to_store[-1]) if history_to_store else None
         for msg in response_messages:
-            msg_dict = msg.model_dump(exclude_none=True) if isinstance(msg, ChatMessage) else msg
-            if json.dumps(msg_dict) != last_stored_content:
+             if json.dumps(msg) != last_stored_content:
                   history_to_store.append(msg)