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

swarm/views/model_views.py

@@ -1,78 +1,135 @@
 """
-Views related to listing and describing available models (Blueprints).
+Model listing views for Open Swarm MCP Core.
+Dynamically discovers blueprints and lists them alongside configured LLMs.
 """
-import logging
-from django.conf import settings
-from django.http import JsonResponse # Not used directly, Response is preferred
-from django.utils.decorators import method_decorator
-from django.views.decorators.csrf import csrf_exempt
-
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework.permissions import AllowAny, IsAuthenticated
-from rest_framework import status
-
+import os
+from django.http import JsonResponse
+from rest_framework.decorators import api_view, permission_classes, authentication_classes
+from rest_framework.permissions import AllowAny # Import AllowAny
 from drf_spectacular.utils import extend_schema
 
-# *** Import async_to_sync ***
-from asgiref.sync import async_to_sync
+from swarm.utils.logger_setup import setup_logger
+# Import the function to discover blueprints, not the metadata variable
+from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
+# Import utility to filter blueprints if needed
+from swarm.extensions.blueprint.blueprint_utils import filter_blueprints
+# Import config loader or access config globally if set up
+# Using utils seems less direct, let's assume config needs loading or is globally available
+# from swarm.views.utils import config # This import might be problematic, load directly if needed
+from swarm.extensions.config.config_loader import load_server_config
+from swarm.settings import BLUEPRINTS_DIR # Import the directory setting
 
-# Import the utility function
-from .utils import get_available_blueprints
-from ..permissions import HasValidTokenOrSession
+logger = setup_logger(__name__)
 
-logger = logging.getLogger(__name__)
+@extend_schema(
+    responses={
+        200: {
+            "type": "object",
+            "properties": {
+                "object": {"type": "string"},
+                "data": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "string"},
+                            "object": {"type": "string"},
+                            "title": {"type": "string"},
+                            "description": {"type": "string"}
+                        }
+                    }
+                }
+            }
+        }
+    },
+    summary="Lists LLMs, config-defined blueprints, and discovered blueprints as models."
+)
+@api_view(["GET"])
+@permission_classes([AllowAny]) # Use AllowAny directly
+@authentication_classes([]) # No authentication required for listing models
+def list_models(request):
+    """List available LLMs, config-defined blueprints, and discovered blueprints."""
+    if request.method != "GET":
+        return JsonResponse({"error": "Method not allowed. Use GET."}, status=405)
 
-# ==============================================================================
-# API Views (DRF based) for Models
-# ==============================================================================
+    try:
+        # Load configuration each time or ensure it's loaded globally/cached
+        config = load_server_config() # Load config to get LLMs and config blueprints
 
-class ListModelsView(APIView):
-    """
-    API view to list available models (Blueprints).
-    Compliant with OpenAI API's /v1/models endpoint structure.
-    """
-    permission_classes = [HasValidTokenOrSession]
+        # 1. LLMs from config (marked as passthrough)
+        llm_config = config.get("llm", {})
+        llm_data = [
+            {
+                "id": key,
+                "object": "llm", # Mark as llm type
+                "title": conf.get("model", key), # Use model name or key as title
+                "description": f"Provider: {conf.get('provider', 'N/A')}, Model: {conf.get('model', 'N/A')}"
+            }
+            for key, conf in llm_config.items() if conf.get("passthrough")
+        ]
 
-    @extend_schema(
-        responses={ # Simplified schema for brevity
-            200: {"description": "A list of available models."}
-        }
-    )
-    # *** Make the handler synchronous ***
-    def get(self, request, *args, **kwargs):
-        """
-        Handles GET requests to list available models.
-        """
+        # 2. Blueprints defined directly in swarm_config.json
+        config_blueprints = config.get("blueprints", {})
+        config_bp_data = [
+            {
+                "id": key,
+                "object": "blueprint", # Mark as blueprint type
+                "title": bp.get("title", key),
+                "description": bp.get("description", f"Blueprint '{key}' from configuration file.")
+            }
+            for key, bp in config_blueprints.items()
+        ]
+
+        # 3. Dynamically discovered blueprints from the blueprints directory
+        # Ensure BLUEPRINTS_DIR is correctly pointing to your blueprints location relative to project root
         try:
-            # *** Call the async utility function using async_to_sync ***
-            # Ensure get_available_blueprints is awaitable (async def or wrapped)
-            available_blueprints_dict = async_to_sync(get_available_blueprints)()
+            # Call discover_blueprints function to get the metadata dictionary
+            discovered_blueprints_metadata = discover_blueprints(directories=[BLUEPRINTS_DIR])
+        except FileNotFoundError:
+             logger.warning(f"Blueprints directory '{BLUEPRINTS_DIR}' not found. No blueprints discovered dynamically.")
+             discovered_blueprints_metadata = {}
+        except Exception as discover_err:
+             logger.error(f"Error discovering blueprints: {discover_err}", exc_info=True)
+             discovered_blueprints_metadata = {}
 
-            models_data = [
-                {
-                    "id": model_id,
-                    "object": "model",
-                    "created": 0, # Placeholder
-                    "owned_by": "open-swarm",
-                    # Access metadata safely
-                    "profile_name": metadata.get('profile_name', 'unknown') if isinstance(metadata, dict) else 'unknown'
-                }
-                # Ensure iteration works correctly
-                for model_id, metadata in (available_blueprints_dict.items() if isinstance(available_blueprints_dict, dict) else [])
-            ]
 
-            response_data = {
-                "object": "list",
-                "data": models_data,
+        # Filter discovered blueprints based on environment variable if set
+        allowed_blueprints_str = os.getenv("SWARM_BLUEPRINTS")
+        if allowed_blueprints_str and allowed_blueprints_str.strip():
+            # Use the imported filter_blueprints utility
+            final_discovered_metadata = filter_blueprints(discovered_blueprints_metadata, allowed_blueprints_str)
+            logger.info(f"Filtering discovered blueprints based on SWARM_BLUEPRINTS env var. Kept: {list(final_discovered_metadata.keys())}")
+        else:
+            final_discovered_metadata = discovered_blueprints_metadata # Use all discovered if no filter
+
+        # Format discovered blueprint data
+        discovered_bp_data = [
+            {
+                "id": key,
+                "object": "blueprint", # Mark as blueprint type
+                "title": meta.get("title", key),
+                "description": meta.get("description", f"Discovered blueprint '{key}'.")
             }
-            # Return the standard sync Response
-            return Response(response_data, status=status.HTTP_200_OK)
+            for key, meta in final_discovered_metadata.items()
+        ]
+
+        # 4. Merge all data sources
+        # Start with LLMs and config blueprints
+        merged_data = llm_data + config_bp_data
+        # Keep track of IDs already added
+        seen_ids = {item["id"] for item in merged_data}
+        # Add discovered blueprints only if their ID hasn't been used by config/LLMs
+        for bp_item in discovered_bp_data:
+            if bp_item["id"] not in seen_ids:
+                merged_data.append(bp_item)
+                seen_ids.add(bp_item["id"]) # Mark ID as seen
+
+        logger.debug(f"Returning {len(merged_data)} models (LLMs + Blueprints).")
+        # Return the merged list in the expected OpenAI-like format
+        return JsonResponse({"object": "list", "data": merged_data}, status=200)
+
+    except Exception as e:
+        # Catch-all for unexpected errors during the process
+        logger.error(f"Error listing models: {e}", exc_info=True)
+        return JsonResponse({"error": "Internal Server Error while listing models."}, status=500)
 
-        except Exception as e:
-            logger.error(f"Error retrieving available blueprints: {e}", exc_info=True)
-            # Return the standard sync Response
-            return Response(
-                {"error": "Internal server error retrieving models."},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )