isa-model 0.4.0__py3-none-any.whl → 0.4.3__py3-none-any.whl

isa_model/serving/api/routes/unified.py

@@ -9,12 +9,12 @@ This is the main API that handles all types of AI requests:
 - Embedding tasks
 """
 
-from fastapi import APIRouter, HTTPException, UploadFile, File, Form, Request, Depends
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form, Request, Depends, Query
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
 from typing import Optional, Dict, Any, Union, List, AsyncGenerator
 import logging
-from ..middleware.auth import optional_auth, require_read_access
+from ..middleware.auth import optional_auth, require_read_access, require_write_access
 from ..middleware.security import rate_limit_standard, rate_limit_heavy, sanitize_input
 import asyncio
 import json
@@ -96,6 +96,30 @@ class UnifiedRequest(BaseModel):
             }
         ]]
     )
+    output_format: Optional[str] = Field(
+        None, 
+        description="输出格式控制。支持的格式：json(JSON结构化输出)、markdown(Markdown格式)、code(代码块提取)、structured(智能结构化解析)。主要用于文本服务的响应格式化。",
+        examples=["json", "markdown", "code", "structured"]
+    )
+    json_schema: Optional[Dict[str, Any]] = Field(
+        None, 
+        description="JSON模式验证。当output_format='json'时使用，用于验证和约束JSON输出格式。遵循JSON Schema规范。",
+        examples=[{
+            "type": "object",
+            "properties": {
+                "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
+                "confidence": {"type": "number", "minimum": 0, "maximum": 1}
+            },
+            "required": ["sentiment", "confidence"]
+        }]
+    )
+    repair_attempts: Optional[int] = Field(
+        3, 
+        ge=0, 
+        le=10,
+        description="JSON修复尝试次数。当解析JSON失败时，系统会尝试修复常见的JSON格式错误。0表示不进行修复尝试。",
+        examples=[3, 0, 5]
+    )
     parameters: Optional[Dict[str, Any]] = Field(
         default_factory=dict, 
         description="额外的任务参数，用于精细控制服务行为。参数内容根据具体服务类型而定，如temperature、max_tokens、voice等。",
@@ -277,7 +301,17 @@ async def unified_invoke(request: Request, user: Dict = Depends(require_read_acc
                     unified_request.input_data = sanitize_input(unified_request.input_data)
                 
             except Exception as e:
-                raise HTTPException(status_code=400, detail=f"Invalid JSON request: {e}")
+                from ..error_handlers import handle_validation_error, create_http_exception, ErrorCode
+                if hasattr(e, 'errors'):  # Pydantic validation error
+                    error_response = handle_validation_error(e)
+                    raise HTTPException(status_code=400, detail=error_response)
+                else:
+                    raise create_http_exception(
+                        f"请求JSON格式错误: {str(e)}",
+                        400,
+                        ErrorCode.INVALID_INPUT,
+                        {"suggestion": "请检查JSON格式和必需字段"}
+                    )
             
             # Prepare parameters, ensuring tools isn't duplicated
             params = dict(unified_request.parameters) if unified_request.parameters else {}
@@ -285,6 +319,14 @@ async def unified_invoke(request: Request, user: Dict = Depends(require_read_acc
                 params.pop("tools", None)  # Remove tools from parameters if present
                 params["tools"] = unified_request.tools
             
+            # Add JSON output formatting parameters
+            if unified_request.output_format:
+                params["output_format"] = unified_request.output_format
+            if unified_request.json_schema:
+                params["json_schema"] = unified_request.json_schema
+            if unified_request.repair_attempts is not None:
+                params["repair_attempts"] = unified_request.repair_attempts
+            
             # Check if this should be a streaming response
             # Default to streaming for text+chat unless explicitly disabled
             is_text_chat = (unified_request.service_type == "text" and unified_request.task == "chat")
@@ -350,8 +392,20 @@ async def unified_invoke(request: Request, user: Dict = Depends(require_read_acc
                                 yield f"data: {json.dumps({'token': item})}\n\n"
                         
                     except Exception as e:
-                        # Send error as final event
-                        yield f"data: {json.dumps({'error': str(e)})}\n\n"
+                        from ..error_handlers import create_error_response, ErrorCode
+                        # Create detailed error response for streaming
+                        error_response = create_error_response(
+                            error=e,
+                            error_code=ErrorCode.INFERENCE_FAILED,
+                            details={
+                                "service_type": unified_request.service_type,
+                                "model": unified_request.model,
+                                "provider": unified_request.provider,
+                                "streaming": True
+                            }
+                        )
+                        # Send structured error as final event
+                        yield f"data: {json.dumps({'error': error_response})}\n\n"
                     finally:
                         # Send end-of-stream marker
                         yield f"data: {json.dumps({'done': True})}\n\n"
@@ -387,11 +441,30 @@ async def unified_invoke(request: Request, user: Dict = Depends(require_read_acc
     except HTTPException:
         raise
     except Exception as e:
+        from ..error_handlers import create_error_response, ErrorCode
         logger.error(f"Unified invoke failed: {e}")
+        
+        # Create detailed error response
+        error_response = create_error_response(
+            error=e,
+            status_code=500,
+            error_code=ErrorCode.INFERENCE_FAILED,
+            details={
+                "service_type": getattr(unified_request, 'service_type', 'unknown'),
+                "model": getattr(unified_request, 'model', 'unknown'),
+                "provider": getattr(unified_request, 'provider', 'unknown'),
+                "task": getattr(unified_request, 'task', 'unknown')
+            }
+        )
+        
         return UnifiedResponse(
             success=False,
-            error=str(e),
-            metadata={}
+            error=error_response.get("error"),
+            metadata={
+                "error_code": error_response.get("error_code"),
+                "user_message": error_response.get("user_message"),
+                "details": error_response.get("details", {})
+            }
         )
 
 
@@ -400,20 +473,71 @@ async def unified_invoke(request: Request, user: Dict = Depends(require_read_acc
 async def get_available_models(service_type: Optional[str] = None):
     """Get available models (optional filter by service type)"""
     try:
-        client = get_isa_client()
-        return await client.get_available_models(service_type)
+        from ..cache_manager import cached, model_list_cache_key
+        
+        @cached(ttl=600.0, cache_key_func=lambda st=service_type: model_list_cache_key(st))  # 10 minutes cache
+        async def _get_models(service_type_param):
+            client = get_isa_client()
+            return await client.get_available_models(service_type_param)
+        
+        models_list = await _get_models(service_type)
+        
+        # Ensure we return the expected format
+        if isinstance(models_list, list):
+            return {
+                "success": True,
+                "models": models_list,
+                "total_count": len(models_list),
+                "service_type_filter": service_type
+            }
+        elif isinstance(models_list, dict) and "models" in models_list:
+            # Already in correct format
+            return models_list
+        else:
+            # Unknown format, convert to expected format
+            return {
+                "success": True,
+                "models": models_list if isinstance(models_list, list) else [],
+                "total_count": len(models_list) if isinstance(models_list, list) else 0,
+                "service_type_filter": service_type
+            }
     except Exception as e:
         logger.error(f"Failed to get available models: {e}")
         # Fallback static model list
+        # Load custom models
+        custom_models = []
+        try:
+            from isa_model.inference.services.custom_model_manager import get_custom_model_manager
+            custom_model_manager = get_custom_model_manager()
+            custom_models = custom_model_manager.get_models_for_api()
+            logger.debug(f"Loaded {len(custom_models)} custom models")
+        except Exception as e:
+            logger.warning(f"Failed to load custom models: {e}")
+        
+        # Base fallback models
+        base_models = [
+            {"service_type": "vision", "provider": "openai", "model_id": "gpt-4o-mini"},
+            {"service_type": "text", "provider": "openai", "model_id": "gpt-4o-mini"},
+            {"service_type": "audio", "provider": "openai", "model_id": "whisper-1"},
+            {"service_type": "audio", "provider": "openai", "model_id": "tts-1"},
+            {"service_type": "embedding", "provider": "openai", "model_id": "text-embedding-3-small"},
+            {"service_type": "image", "provider": "replicate", "model_id": "black-forest-labs/flux-schnell"}
+        ]
+        
+        # Combine base models with custom models
+        fallback_models = base_models + custom_models
+        
+        # Filter by service_type if provided
+        if service_type:
+            fallback_models = [m for m in fallback_models if m["service_type"] == service_type]
+        
         return {
-            "models": [
-                {"service_type": "vision", "provider": "openai", "model_id": "gpt-4.1-mini"},
-                {"service_type": "text", "provider": "openai", "model_id": "gpt-4.1-mini"},
-                {"service_type": "audio", "provider": "openai", "model_id": "whisper-1"},
-                {"service_type": "audio", "provider": "openai", "model_id": "tts-1"},
-                {"service_type": "embedding", "provider": "openai", "model_id": "text-embedding-3-small"},
-                {"service_type": "image", "provider": "replicate", "model_id": "black-forest-labs/flux-schnell"}
-            ]
+            "success": False,
+            "error": f"Failed to get models: {str(e)}",
+            "models": fallback_models,
+            "total_count": len(fallback_models),
+            "service_type_filter": service_type,
+            "fallback": True
         }
 
 @router.get("/health")
@@ -430,4 +554,542 @@ async def health_check():
         return {
             "api": "error",
             "error": str(e)
-        }
+        }
+
+# Enhanced Model Management API Endpoints
+
+@router.get("/models/search")
+async def search_models(
+    query: str = Query(..., description="Search query"),
+    model_type: Optional[str] = Query(None, description="Filter by model type"),
+    provider: Optional[str] = Query(None, description="Filter by provider"),
+    capabilities: Optional[List[str]] = Query(None, description="Filter by capabilities"),
+    limit: int = Query(50, ge=1, le=200, description="Maximum number of results"),
+    user = Depends(optional_auth)
+):
+    """Search models by query and filters"""
+    try:
+        # Try database search first
+        try:
+            from isa_model.core.models.model_repo import ModelRepo
+            
+            repo = ModelRepo()
+            
+            # Convert capabilities from query parameter
+            capability_list = None
+            if capabilities:
+                capability_list = [cap.strip() for cap in capabilities if cap.strip()]
+            
+            results = repo.search_models(
+                query=query,
+                model_type=model_type,
+                provider=provider,
+                capabilities=capability_list,
+                limit=limit
+            )
+            
+            # If we got results from the database, return them
+            if results:
+                return {
+                    "success": True,
+                    "query": query,
+                    "filters": {
+                        "model_type": model_type,
+                        "provider": provider,
+                        "capabilities": capability_list
+                    },
+                    "results": [
+                        {
+                            "model_id": model.model_id,
+                            "model_type": model.model_type,
+                            "provider": model.provider,
+                            "description": model.metadata.get("description", ""),
+                            "capabilities": model.capabilities,
+                            "updated_at": model.updated_at.isoformat() if model.updated_at else None
+                        }
+                        for model in results
+                    ],
+                    "total_results": len(results)
+                }
+            
+        except Exception as db_error:
+            logger.warning(f"Database search failed, using fallback: {db_error}")
+        
+        # Fallback: search in our hardcoded model list + custom models
+        # Load custom models
+        custom_models_for_search = []
+        try:
+            from isa_model.inference.services.custom_model_manager import get_custom_model_manager
+            custom_model_manager = get_custom_model_manager()
+            custom_models_for_search = custom_model_manager.get_models_for_api()
+            # Convert format for search
+            for model in custom_models_for_search:
+                model["model_type"] = model.get("service_type", "text")
+        except Exception as e:
+            logger.warning(f"Failed to load custom models for search: {e}")
+        
+        fallback_models = [
+            {
+                "model_id": "gpt-4o-mini",
+                "model_type": "text",
+                "provider": "openai",
+                "description": "Small, fast GPT-4 model optimized for efficiency",
+                "capabilities": ["chat", "text_generation", "reasoning"],
+                "service_type": "text"
+            },
+            {
+                "model_id": "gpt-4o",
+                "model_type": "text", 
+                "provider": "openai",
+                "description": "Large GPT-4 model with enhanced capabilities",
+                "capabilities": ["chat", "text_generation", "reasoning", "image_understanding"],
+                "service_type": "text"
+            },
+            {
+                "model_id": "text-embedding-3-small",
+                "model_type": "embedding",
+                "provider": "openai", 
+                "description": "Small embedding model for text vectorization",
+                "capabilities": ["embedding", "similarity"],
+                "service_type": "embedding"
+            },
+            {
+                "model_id": "whisper-1",
+                "model_type": "audio",
+                "provider": "openai",
+                "description": "Speech recognition and transcription model",
+                "capabilities": ["speech_to_text", "audio_transcription"],
+                "service_type": "audio"
+            },
+            {
+                "model_id": "tts-1",
+                "model_type": "audio",
+                "provider": "openai",
+                "description": "Text-to-speech generation model",
+                "capabilities": ["text_to_speech"],
+                "service_type": "audio"
+            },
+            {
+                "model_id": "flux-schnell",
+                "model_type": "image",
+                "provider": "replicate",
+                "description": "Fast image generation model",
+                "capabilities": ["image_generation"],
+                "service_type": "image"
+            },
+            {
+                "model_id": "isa-llm-service",
+                "model_type": "text",
+                "provider": "isa",
+                "description": "ISA custom LLM service for trained models",
+                "capabilities": ["chat", "text_generation"],
+                "service_type": "text"
+            },
+            {
+                "model_id": "isa-omniparser-ui-detection",
+                "model_type": "vision",
+                "provider": "isa",
+                "description": "UI element detection and analysis",
+                "capabilities": ["ui_detection", "image_analysis"],
+                "service_type": "vision"
+            }
+        ]
+        
+        # Add custom models to search list
+        fallback_models.extend(custom_models_for_search)
+        
+        # Apply search filters
+        query_lower = query.lower()
+        filtered_models = []
+        
+        for model in fallback_models:
+            # Check if query matches
+            query_match = (
+                query_lower in model["model_id"].lower() or
+                query_lower in model["provider"].lower() or
+                query_lower in model["description"].lower() or
+                any(query_lower in cap.lower() for cap in model["capabilities"])
+            )
+            
+            if not query_match:
+                continue
+                
+            # Apply type filter
+            if model_type and model["model_type"] != model_type:
+                continue
+                
+            # Apply provider filter 
+            if provider and model["provider"] != provider:
+                continue
+                
+            # Apply capabilities filter
+            if capabilities:
+                if not any(cap in model["capabilities"] for cap in capabilities):
+                    continue
+            
+            filtered_models.append({
+                "model_id": model["model_id"],
+                "model_type": model["model_type"],
+                "provider": model["provider"],
+                "description": model["description"],
+                "capabilities": model["capabilities"],
+                "updated_at": None
+            })
+        
+        # Apply limit
+        limited_results = filtered_models[:limit]
+        
+        return {
+            "success": True,
+            "query": query,
+            "filters": {
+                "model_type": model_type,
+                "provider": provider,
+                "capabilities": capabilities
+            },
+            "results": limited_results,
+            "total_results": len(limited_results),
+            "fallback": True,
+            "message": "Using fallback search - database search unavailable"
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to search models: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to search models: {str(e)}")
+
+@router.get("/models/providers")
+async def get_model_providers(user = Depends(optional_auth)):
+    """Get list of available model providers"""
+    try:
+        from ..cache_manager import cached, provider_list_cache_key
+        
+        @cached(ttl=600.0, cache_key_func=lambda: provider_list_cache_key())  # 10 minutes cache
+        async def _get_providers():
+            try:
+                from isa_model.core.models.model_repo import ModelRepo
+                repo = ModelRepo()
+                return repo.get_providers_summary()
+            except Exception as e:
+                logger.warning(f"ModelRepo failed, using fallback: {e}")
+                # Fallback to basic provider list
+                return [
+                    {
+                        "provider": "openai",
+                        "model_count": 4,
+                        "model_types": ["text", "vision", "audio", "embedding"],
+                        "capabilities": ["chat", "completion", "embedding", "vision", "audio"]
+                    },
+                    {
+                        "provider": "isa",
+                        "model_count": 3,
+                        "model_types": ["text", "vision", "embedding"],
+                        "capabilities": ["chat", "completion", "ui_detection", "ocr"]
+                    },
+                    {
+                        "provider": "replicate",
+                        "model_count": 2,
+                        "model_types": ["image", "video"],
+                        "capabilities": ["image_generation", "video_generation"]
+                    }
+                ]
+        
+        providers = await _get_providers()
+        
+        return {
+            "success": True,
+            "providers": providers,
+            "total_count": len(providers),
+            "cached": True
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get model providers: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get model providers: {str(e)}")
+
+@router.get("/models/custom")
+async def get_custom_models(
+    model_type: Optional[str] = Query(None, description="Filter by model type"),
+    provider: Optional[str] = Query(None, description="Filter by provider"),
+    user = Depends(optional_auth)
+):
+    """Get list of custom trained models"""
+    try:
+        from ..cache_manager import cached, custom_models_cache_key
+        from isa_model.inference.services.custom_model_manager import get_custom_model_manager
+        
+        @cached(ttl=300.0, cache_key_func=lambda mt=model_type, p=provider: custom_models_cache_key(mt, p))  # 5 minutes cache
+        async def _get_custom_models(model_type_param, provider_param):
+            custom_model_manager = get_custom_model_manager()
+            return custom_model_manager.list_models(model_type=model_type_param, provider=provider_param)
+        
+        models = await _get_custom_models(model_type, provider)
+        
+        # Convert to API format
+        api_models = []
+        for model in models:
+            api_model = {
+                "model_id": model.model_id,
+                "model_name": model.model_name,
+                "model_type": model.model_type,
+                "provider": model.provider,
+                "base_model": model.base_model,
+                "training_date": model.training_date,
+                "description": model.metadata.get("description", ""),
+                "capabilities": model.capabilities,
+                "custom": True
+            }
+            
+            if model.performance_metrics:
+                api_model["performance_metrics"] = model.performance_metrics
+            
+            if model.deployment_config:
+                api_model["deployment_status"] = "configured"
+            
+            api_models.append(api_model)
+        
+        return {
+            "success": True,
+            "custom_models": api_models,
+            "total_count": len(api_models),
+            "filters": {
+                "model_type": model_type,
+                "provider": provider
+            },
+            "stats": custom_model_manager.get_stats()
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get custom models: {e}")
+        return {
+            "success": False,
+            "error": str(e),
+            "custom_models": [],
+            "total_count": 0
+        }
+
+@router.get("/models/capabilities")
+async def get_model_capabilities(user = Depends(optional_auth)):
+    """Get list of all available model capabilities"""
+    try:
+        from ..cache_manager import cached
+        
+        @cached(ttl=3600.0, cache_key_func=lambda: "model_capabilities")  # 1 hour cache (static data)
+        async def _get_capabilities():
+            from isa_model.core.models.model_repo import ModelCapability
+            
+            return [
+                {
+                    "capability": cap.value,
+                    "description": cap.value.replace("_", " ").title()
+                }
+                for cap in ModelCapability
+            ]
+        
+        capabilities = await _get_capabilities()
+        
+        return {
+            "success": True,
+            "capabilities": capabilities
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get model capabilities: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get model capabilities: {str(e)}")
+
+@router.get("/models/{model_id}")
+async def get_model_details(model_id: str, user = Depends(optional_auth)):
+    """Get detailed information about a specific model"""
+    try:
+        from ..cache_manager import cached
+        from isa_model.core.models.model_repo import ModelRepo
+        
+        @cached(ttl=900.0, cache_key_func=lambda mid=model_id: f"model_details_{mid}")  # 15 minutes cache
+        async def _get_model_details(model_id_param):
+            repo = ModelRepo()
+            return repo.get_model_by_id(model_id_param)
+        
+        model = await _get_model_details(model_id)
+        
+        if not model:
+            raise HTTPException(status_code=404, detail=f"Model not found: {model_id}")
+        
+        return {
+            "success": True,
+            "model": {
+                "model_id": model.model_id,
+                "model_type": model.model_type,
+                "provider": model.provider,
+                "metadata": model.metadata,
+                "capabilities": model.capabilities,
+                "created_at": model.created_at.isoformat() if model.created_at else None,
+                "updated_at": model.updated_at.isoformat() if model.updated_at else None
+            }
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get model details for {model_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get model details: {str(e)}")
+
+@router.get("/models/{model_id}/versions")
+async def get_model_versions(model_id: str, user = Depends(optional_auth)):
+    """Get version history for a specific model"""
+    try:
+        from isa_model.core.models.model_version_manager import ModelVersionManager
+        
+        version_manager = ModelVersionManager()
+        versions = version_manager.get_model_versions(model_id)
+        
+        return {
+            "success": True,
+            "model_id": model_id,
+            "versions": [
+                {
+                    "version": v.version,
+                    "created_at": v.created_at.isoformat(),
+                    "metadata": v.metadata,
+                    "is_active": v.is_active
+                }
+                for v in versions
+            ],
+            "total_versions": len(versions)
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get model versions for {model_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get model versions: {str(e)}")
+
+@router.post("/models/{model_id}/versions")
+async def create_model_version(
+    model_id: str,
+    version_data: Dict[str, Any],
+    user = Depends(require_write_access)
+):
+    """Create a new version for a model"""
+    try:
+        from isa_model.core.models.model_version_manager import ModelVersionManager
+        
+        version_manager = ModelVersionManager()
+        new_version = version_manager.create_version(
+            model_id=model_id,
+            metadata=version_data.get("metadata", {}),
+            user_id=user.get("user_id") if user else None
+        )
+        
+        return {
+            "success": True,
+            "message": f"New version created for model {model_id}",
+            "version": {
+                "version": new_version.version,
+                "created_at": new_version.created_at.isoformat(),
+                "metadata": new_version.metadata
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to create model version for {model_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to create model version: {str(e)}")
+
+@router.get("/models/{model_id}/billing")
+async def get_model_billing_info(
+    model_id: str,
+    start_date: Optional[str] = Query(None, description="Start date (ISO format)"),
+    end_date: Optional[str] = Query(None, description="End date (ISO format)"),
+    user = Depends(optional_auth)
+):
+    """Get billing information for a specific model"""
+    try:
+        from isa_model.core.models.model_billing_tracker import ModelBillingTracker
+        from datetime import datetime, timedelta
+        
+        # Parse dates
+        if start_date:
+            start_dt = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+        else:
+            start_dt = datetime.now() - timedelta(days=30)
+            
+        if end_date:
+            end_dt = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+        else:
+            end_dt = datetime.now()
+        
+        billing_tracker = ModelBillingTracker()
+        billing_info = billing_tracker.get_model_billing_summary(
+            model_id=model_id,
+            start_date=start_dt,
+            end_date=end_dt
+        )
+        
+        return {
+            "success": True,
+            "model_id": model_id,
+            "billing_period": {
+                "start_date": start_dt.isoformat(),
+                "end_date": end_dt.isoformat()
+            },
+            "billing_summary": billing_info
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get billing info for {model_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get billing info: {str(e)}")
+
+@router.put("/models/{model_id}/metadata")
+async def update_model_metadata(
+    model_id: str,
+    metadata_update: Dict[str, Any],
+    user = Depends(require_write_access)
+):
+    """Update metadata for a specific model"""
+    try:
+        from isa_model.core.models.model_repo import ModelRepo
+        
+        repo = ModelRepo()
+        success = repo.update_model_metadata(
+            model_id=model_id,
+            metadata_updates=metadata_update,
+            updated_by=user.get("user_id") if user else None
+        )
+        
+        if not success:
+            raise HTTPException(status_code=404, detail=f"Model not found: {model_id}")
+        
+        return {
+            "success": True,
+            "message": f"Metadata updated for model {model_id}",
+            "updated_fields": list(metadata_update.keys())
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to update metadata for {model_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to update metadata: {str(e)}")
+
+@router.get("/models/{model_id}/statistics")
+async def get_model_statistics(
+    model_id: str,
+    days: int = Query(30, ge=1, le=365, description="Number of days for statistics"),
+    user = Depends(optional_auth)
+):
+    """Get usage statistics for a specific model"""
+    try:
+        from isa_model.core.models.model_statistics_tracker import ModelStatisticsTracker
+        
+        stats_tracker = ModelStatisticsTracker()
+        statistics = stats_tracker.get_model_statistics(
+            model_id=model_id,
+            days=days
+        )
+        
+        return {
+            "success": True,
+            "model_id": model_id,
+            "period_days": days,
+            "statistics": statistics
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get statistics for {model_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get model statistics: {str(e)}")