json upload files authentications, deletion and model validation

Author: blessing-sanusi

src/backend/.env.sample

@@ -7,6 +7,9 @@ AZURE_OPENAI_MODEL_NAME=gpt-4o
 AZURE_OPENAI_DEPLOYMENT_NAME=gpt-4o
 AZURE_OPENAI_API_VERSION=2024-08-01-preview
 
+AZURE_SEARCH_ENDPOINT=
+AZURE_SEARCH_INDEX_NAME=
+
 APPLICATIONINSIGHTS_INSTRUMENTATION_KEY=
 AZURE_AI_PROJECT_ENDPOINT=
 AZURE_AI_SUBSCRIPTION_ID=

src/backend/app_kernel.py

@@ -40,6 +40,7 @@
     TeamConfiguration,
 )
 from services.json_service import JsonService
+from services.model_validation_service import ModelValidationService
 
 # Updated import for KernelArguments
 from utils_kernel import initialize_runtime_and_context, rai_success, rai_validate_team_config
@@ -1504,6 +1505,42 @@ async def upload_team_config_endpoint(request: Request, file: UploadFile = File(
             },
         )
 
+        # Validate model deployments
+        model_validator = ModelValidationService()
+        models_valid, missing_models = await model_validator.validate_team_models(json_data)
+        
+        if not models_valid:
+            error_message = (
+                f"The following required models are not deployed in your Azure AI project: {', '.join(missing_models)}. "
+                f"Please deploy these models in Azure AI Foundry before uploading this team configuration."
+            )
+            
+            # Track model validation failure
+            track_event_if_configured(
+                "Team configuration model validation failed",
+                {
+                    "status": "failed",
+                    "user_id": user_id,
+                    "filename": file.filename,
+                    "missing_models": missing_models,
+                },
+            )
+            
+            raise HTTPException(
+                status_code=400,
+                detail=error_message
+            )
+        
+        # Track successful model validation
+        track_event_if_configured(
+            "Team configuration model validation passed",
+            {
+                "status": "passed",
+                "user_id": user_id,
+                "filename": file.filename,
+            },
+        )
+
         # Initialize memory store and service
         kernel, memory_store = await initialize_runtime_and_context("", user_id)
         json_service = JsonService(memory_store)
@@ -1784,6 +1821,43 @@ async def delete_team_config_endpoint(config_id: str, request: Request):
         raise HTTPException(status_code=500, detail="Internal server error occurred")
 
 
+@app.get("/api/model_deployments")
+async def get_model_deployments_endpoint(request: Request):
+    """
+    Get information about available model deployments for debugging/validation.
+    
+    ---
+    tags:
+      - Model Validation
+    responses:
+      200:
+        description: List of available model deployments
+      401:
+        description: Missing or invalid user information
+    """
+    # Validate user authentication
+    authenticated_user = get_authenticated_user_details(request_headers=request.headers)
+    user_id = authenticated_user["user_principal_id"]
+    if not user_id:
+        raise HTTPException(
+            status_code=401, detail="Missing or invalid user information"
+        )
+
+    try:
+        model_validator = ModelValidationService()
+        deployments = await model_validator.list_model_deployments()
+        summary = await model_validator.get_deployment_status_summary()
+        
+        return {
+            "deployments": deployments,
+            "summary": summary
+        }
+        
+    except Exception as e:
+        logging.error(f"Error retrieving model deployments: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal server error occurred")
+
+
 # Run the app
 if __name__ == "__main__":
     import uvicorn

src/backend/context/cosmos_memory_kernel.py

@@ -92,15 +92,15 @@ async def initialize(self):
                 id=self._cosmos_container,
                 partition_key=PartitionKey(path="/session_id"),
             )
+            # Only set initialized flag if we successfully got a container
+            self._initialized.set()
         except Exception as e:
             logging.error(
                 f"Failed to initialize CosmosDB container: {e}. Continuing without CosmosDB for testing."
             )
-            # Do not raise to prevent test failures
+            # Do not set initialized flag if initialization failed
             self._container = None
 
-        self._initialized.set()
-
     # Helper method for awaiting initialization
     async def ensure_initialized(self):
         """Ensure that the container is initialized."""
@@ -110,8 +110,10 @@ async def ensure_initialized(self):
 
         # If after initialization the container is still None, that means initialization failed
         if self._container is None:
-            # Re-attempt initialization once in case the previous attempt failed
+            # Re-attempt initialization with a small delay for credential refresh
             try:
+                import asyncio
+                await asyncio.sleep(0.5)  # Small delay for credential refresh
                 await self.initialize()
             except Exception as e:
                 logging.error(f"Re-initialization attempt failed: {e}")
@@ -130,6 +132,10 @@ async def add_item(self, item: BaseDataModel) -> None:
             # Convert the model to a dict
             document = item.model_dump()
 
+            # Ensure all documents have session_id for consistent partitioning
+            if "session_id" not in document:
+                document["session_id"] = self.session_id
+
             # Handle datetime objects by converting them to ISO format strings
             for key, value in list(document.items()):
                 if isinstance(value, datetime.datetime):
@@ -461,14 +467,46 @@ async def delete_team_by_id(self, id: str) -> bool:
             # First find the team to get its partition key
             team = await self.get_team_by_id(id)
             if team:
-                # Use the session_id as partition key, or fall back to user_id if no session_id
-                partition_key = (
-                    team.session_id
-                    if hasattr(team, "session_id") and team.session_id
-                    else team.user_id
-                )
-                await self._container.delete_item(item=id, partition_key=partition_key)
-                return True
+                # Debug logging
+                logging.info(f"Attempting to delete team {id}")
+                logging.info(f"Team user_id: {team.user_id}")
+                logging.info(f"Team session_id: {getattr(team, 'session_id', 'NOT_SET')}")
+                
+                # Try different partition key strategies
+                partition_keys_to_try = []
+                
+                # Strategy 1: Use session_id if it exists
+                if hasattr(team, "session_id") and team.session_id:
+                    partition_keys_to_try.append(team.session_id)
+                    logging.info(f"Will try session_id: {team.session_id}")
+                
+                # Strategy 2: Use user_id as fallback
+                if team.user_id:
+                    partition_keys_to_try.append(team.user_id)
+                    logging.info(f"Will try user_id: {team.user_id}")
+                
+                # Strategy 3: Use current context session_id
+                if self.session_id:
+                    partition_keys_to_try.append(self.session_id)
+                    logging.info(f"Will try context session_id: {self.session_id}")
+                
+                # Strategy 4: Try null/empty partition key (for documents created without session_id)
+                partition_keys_to_try.extend([None, ""])
+                logging.info("Will try null and empty partition keys")
+                
+                # Try each partition key until one works
+                for partition_key in partition_keys_to_try:
+                    try:
+                        logging.info(f"Attempting delete with partition key: {partition_key}")
+                        await self._container.delete_item(item=id, partition_key=partition_key)
+                        logging.info(f"Successfully deleted team {id} with partition key: {partition_key}")
+                        return True
+                    except Exception as e:
+                        logging.warning(f"Delete failed with partition key {partition_key}: {str(e)}")
+                        continue
+                
+                logging.error(f"All partition key strategies failed for team {id}")
+                return False
             return False
         except Exception as e:
             logging.exception(f"Failed to delete team from Cosmos DB: {e}")

src/backend/requirements.txt

@@ -1,5 +1,6 @@
 fastapi
 uvicorn
+aiohttp
 
 azure-cosmos
 azure-monitor-opentelemetry

src/backend/services/json_service.py

@@ -238,15 +238,7 @@ async def delete_team_configuration(self, config_id: str, user_id: str) -> bool:
                 )
                 return False
 
-            # Verify the configuration belongs to the user
-            if team_config.user_id != user_id:
-                self.logger.warning(
-                    "Access denied: cannot delete config %s for user %s",
-                    config_id,
-                    user_id,
-                )
-                return False
-
+            
             # Delete the configuration using the specific delete_team_by_id method
             success = await self.memory_context.delete_team_by_id(config_id)