Update app.py

app.py

@@ -2141,6 +2141,12 @@ class MyScene(Scene):
                             # Get model configuration
                             config = MODEL_CONFIGS.get(model_name, MODEL_CONFIGS["default"])
                             
+                            # Check if this is a model that requires max_completion_tokens
+                            if config["param_name"] == "max_completion_tokens":
+                                st.warning(f"Model {model_name} requires special handling that isn't fully supported. Testing with gpt-4o instead.")
+                                model_name = "gpt-4o"
+                                config = MODEL_CONFIGS["gpt-4o"]
+                            
                             # Create client with appropriate API version
                             api_version = config.get("api_version")
                             if api_version:
@@ -2156,16 +2162,11 @@ class MyScene(Scene):
                                 )
                             
                             # Test with a simple prompt
-                            api_params = {
-                                "messages": [UserMessage("Hello, this is a connection test.")],
-                                "model": model_name
-                            }
-                            
-                            # Use appropriate parameter name
-                            api_params[config["param_name"]] = 100  # Just enough for a short response
-                            
-                            # Make the API call
-                            response = client.complete(**api_params)
+                            response = client.complete(
+                                messages=[UserMessage("Hello, this is a connection test.")],
+                                model=model_name,
+                                max_tokens=50  # Small value for quick testing
+                            )
                             
                             # Check if response is valid
                             if response and response.choices and len(response.choices) > 0:
@@ -2210,14 +2211,18 @@ class MyScene(Scene):
                     for model_name in sorted(model_categories[category]):
                         config = MODEL_CONFIGS[model_name]
                         is_selected = model_name == st.session_state.custom_model
+                        warning = config.get("warning")
                         
                         # Create styled card for each model
+                        warning_html = f'<p style="color: #ff9800; font-size: 0.8rem; margin-top: 5px;">⚠️ {warning}</p>' if warning else ""
+                        
                         st.markdown(f"""
                         <div class="model-card {'selected-model' if is_selected else ''}">
                             <h4>{model_name}</h4>
                             <div class="model-details">
                                 <p>Max Tokens: {config['max_tokens']:,}</p>
                                 <p>API Version: {config['api_version'] if config['api_version'] else 'Default'}</p>
+                                {warning_html}
                             </div>
                         </div>
                         """, unsafe_allow_html=True)
@@ -2242,28 +2247,19 @@ class MyScene(Scene):
                         model_name = st.session_state.custom_model
                         config = MODEL_CONFIGS.get(model_name, MODEL_CONFIGS["default"])
                         
-                        # Use appropriate parameters based on model configuration
-                        api_params = {
-                            "messages": [UserMessage("Hello")],
-                            "model": model_name
-                        }
-                        api_params[config["param_name"]] = 10  # Just request 10 tokens for quick test
+                        # Check if this is a model that requires max_completion_tokens
+                        if config["param_name"] == "max_completion_tokens":
+                            st.warning(f"Model {model_name} requires special handling that isn't fully supported. Using gpt-4o instead.")
+                            model_name = "gpt-4o"
+                            config = MODEL_CONFIGS["gpt-4o"]
                         
-                        if config["api_version"]:
-                            # Create version-specific client if needed
-                            token = get_secret("github_token_api")
-                            from azure.ai.inference import ChatCompletionsClient
-                            from azure.core.credentials import AzureKeyCredential
-                            
-                            client = ChatCompletionsClient(
-                                endpoint=st.session_state.ai_models["endpoint"],
-                                credential=AzureKeyCredential(token),
-                                api_version=config["api_version"]
-                            )
-                            response = client.complete(**api_params)
-                        else:
-                            response = st.session_state.ai_models["client"].complete(**api_params)
-                            
+                        # Use appropriate parameters based on model configuration
+                        response = st.session_state.ai_models["client"].complete(
+                            messages=[UserMessage("Hello")],
+                            model=model_name,
+                            max_tokens=10  # Just request 10 tokens for quick test
+                        )
+                                
                         st.success(f"✅ Connection to {model_name} successful!")
                         st.session_state.ai_models["model_name"] = model_name
                         
@@ -2305,13 +2301,19 @@ class MyScene(Scene):
                     if code_input:
                         with st.spinner("AI is generating your animation code..."):
                             try:
-                                # Direct implementation of code generation
+                                # Get the client and model name
                                 client = st.session_state.ai_models["client"]
                                 model_name = st.session_state.ai_models["model_name"]
                                 
                                 # Get configuration for this model
                                 config = MODEL_CONFIGS.get(model_name, MODEL_CONFIGS["default"])
                                 
+                                # Check if this model requires max_completion_tokens
+                                if config["param_name"] == "max_completion_tokens":
+                                    st.warning(f"Model {model_name} requires special handling that isn't fully supported. Using gpt-4o instead.")
+                                    model_name = "gpt-4o"
+                                    config = MODEL_CONFIGS["gpt-4o"]
+                                
                                 # Create the prompt
                                 prompt = f"""Write a complete Manim animation scene based on this code or idea:
 {code_input}
@@ -2325,42 +2327,13 @@ The code should be a complete, working Manim animation that includes:
 Here's the complete Manim code:
 """
                                 
-                                # Prepare API call parameters based on model requirements
-                                api_params = {
-                                    "messages": [UserMessage(prompt)],
-                                    "model": model_name
-                                }
-                                
-                                # Add the appropriate token parameter
-                                api_params[config["param_name"]] = config["max_tokens"]
-                                
-                                # Check if we need to specify API version
-                                if config["api_version"]:
-                                    # If we need a specific API version, create a new client with that version
-                                    logger.info(f"Using API version {config['api_version']} for model {model_name}")
-                                    
-                                    # Get token from session state
-                                    token = get_secret("github_token_api")
-                                    if not token:
-                                        st.error("GitHub token not found in secrets")
-                                        return None
-                                    
-                                    # Import required modules for creating client with specific API version
-                                    from azure.ai.inference import ChatCompletionsClient
-                                    from azure.core.credentials import AzureKeyCredential
-                                    
-                                    # Create client with specific API version
-                                    version_specific_client = ChatCompletionsClient(
-                                        endpoint=st.session_state.ai_models["endpoint"],
-                                        credential=AzureKeyCredential(token),
-                                        api_version=config["api_version"]
-                                    )
-                                    
-                                    # Make the API call with the version-specific client
-                                    response = version_specific_client.complete(**api_params)
-                                else:
-                                    # Use the existing client
-                                    response = client.complete(**api_params)
+                                # Make the API call with proper parameters
+                                from azure.ai.inference.models import UserMessage
+                                response = client.complete(
+                                    messages=[UserMessage(prompt)],
+                                    model=model_name,
+                                    max_tokens=config["max_tokens"]
+                                )
                                 
                                 # Process the response
                                 if response and response.choices and len(response.choices) > 0: