🤖 Auto-deploy from GitHub (push) - d2954f9 - 2025-07-27 04:52:05 UTC

.env.example

@@ -1,12 +1,27 @@
 # Copy this file to .env and fill in your API keys
 # Required for the fitness agent to work
 
-# OpenAI API Key (or other LLM provider)
+# === OPTION 1: OpenAI Models ===
+# For GPT-4o, GPT-4 Turbo, GPT-3.5, o1-preview, o1-mini, o3-mini
 OPENAI_API_KEY=your_openai_api_key_here
 
-# Alternative: If using other providers through LiteLLM
+# === OPTION 2: Anthropic Models ===  
+# For Claude-4, Claude-3.7, Claude-3.5, Claude-3 models
+ANTHROPIC_API_KEY=your_anthropic_key_here
+
+# === OPTION 3: Both Providers ===
+# Set both keys to have access to all models
+# OPENAI_API_KEY=your_openai_api_key_here
 # ANTHROPIC_API_KEY=your_anthropic_key_here
-# GOOGLE_API_KEY=your_google_key_here
+
+# Optional: Set default model (will use claude-3.5-haiku if not set)
+# AI_MODEL=gpt-4o-mini
+# AI_MODEL=claude-3.5-sonnet
+# AI_MODEL=gpt-4o
+
+# Alternative environment variable names (for compatibility)
+# ANTHROPIC_MODEL=claude-3.5-haiku
+# OPENAI_MODEL=gpt-4o-mini
 
 # Optional: Hugging Face token for some features
 # HF_TOKEN=your_huggingface_token_here

README.md

@@ -12,16 +12,31 @@ license: mit
 
 # 🏋️‍♀️ Fitness AI Assistant
 
-Your personal fitness companion for workout plans, meal planning, and fitness guidance powered by Anthropic's Claude models.
+Your personal fitness companion for workout plans, meal planning, and fitness guidance powered by **multiple AI providers** - choose between Anthropic Claude and OpenAI GPT models!
 
 ## ✨ Features
 
 - **🏋️ Personalized Workout Plans**: Custom routines based on your fitness level and goals
-- **🥗 Meal Planning**: Tailored nutrition plans for weight loss, muscle gain, or general health
+- **🥗 Meal Planning**: Tailored nutrition plans for weight loss, muscle gain, or general health  
 - **💡 Fitness Guidance**: Expert advice on exercises, form, and best practices
-- **🤖 Multiple AI Models**: Choose from Claude-3.5-Haiku to Claude-4-Opus based on your needs
+- **🤖 Multiple AI Providers**: Choose from Anthropic Claude OR OpenAI GPT models
+- **⚡ Model Flexibility**: Switch between models anytime for different capabilities
 - **💬 Interactive Chat**: Conversational interface with memory and context
-- **⚡ Real-time Streaming**: See responses generated live
+- **🔄 Real-time Streaming**: See responses generated live
+
+## 🤖 Supported AI Models
+
+### 🔵 Anthropic Claude Models
+- **Claude-4**: claude-4-opus, claude-4-sonnet (Premium, most capable)
+- **Claude-3.7**: claude-3.7-sonnet (Extended thinking)
+- **Claude-3.5**: claude-3.5-sonnet, claude-3.5-haiku (Balanced, fast)
+- **Claude-3**: claude-3-haiku (Cost-effective)
+
+### 🟢 OpenAI GPT Models  
+- **GPT-4o**: gpt-4o, gpt-4o-mini (Latest with vision)
+- **GPT-4**: gpt-4-turbo (Large context window)
+- **GPT-3.5**: gpt-3.5-turbo (Fast and economical)
+- **Reasoning**: o1-preview, o1-mini, o3-mini (Advanced reasoning)
 
 ## 🚀 Quick Start
 
@@ -34,16 +49,22 @@ cd fitness-app
 # Install dependencies
 pip install -r requirements.txt
 
-# Set up environment
+# Set up environment - choose your provider(s)
 cp .env.example .env
-# Edit .env and add your ANTHROPIC_API_KEY
+
+# Edit .env and add your API key(s):
+# For OpenAI models: OPENAI_API_KEY=your_openai_key_here
+# For Anthropic models: ANTHROPIC_API_KEY=your_anthropic_key_here  
+# For both providers: Set both keys!
 
 # Launch the app
 python fitness_agent/app.py
 ```
 
 ### Option 2: Use the Interface
-1. **Select your AI model** from the dropdown (default: claude-3.5-haiku)
+1. **Select your AI provider and model** from the dropdown
+   - 🔵 Anthropic models for detailed analysis and safety
+   - 🟢 OpenAI models for familiar interface and vision capabilities
 2. **Start chatting** about your fitness goals
 3. **Be specific** about your level, equipment, and preferences
 4. **Get personalized plans** and ask follow-up questions

fitness_agent/app.py

@@ -113,16 +113,31 @@ def change_model(new_model: str) -> str:
         
         # Test if we can create an agent with this model (basic validation)
         try:
+            logger.info(f"Attempting to create test agent with model: {new_model}")
             test_agent = FitnessAgent(new_model)
+            logger.info(f"Successfully created test agent with model: {new_model}")
             # If we get here, the model is likely available
         except Exception as model_error:
-            # Check if it's a "not found" error specifically
+            # Get the full error details for debugging
             error_str = str(model_error)
-            if "not_found_error" in error_str or "NotFoundError" in error_str:
+            error_repr = repr(model_error)
+            error_type = type(model_error).__name__
+            
+            logger.error(f"Model initialization error for {new_model}:")
+            logger.error(f"  Error type: {error_type}")
+            logger.error(f"  Error string: {error_str}")
+            logger.error(f"  Error repr: {error_repr}")
+            
+            # Clean up error message for display
+            clean_error = error_str.replace('\n', ' ').replace('\r', ' ')
+            clean_error = clean_error[:400] + "..." if len(clean_error) > 400 else clean_error
+            
+            # Check for specific error types
+            if "not_found_error" in error_str.lower() or "notfounderror" in error_str.lower():
                 recommended = ", ".join(FitnessAgent.get_recommended_models())
                 return f"""❌ **Model Not Available**
 
-🚫 **Error:** Model `{new_model}` is not currently available on your Anthropic API account.
+🚫 **Error:** Model `{new_model}` is not currently available on your API account.
 
 💡 **This could mean:**
 - The model requires special access or higher tier subscription
@@ -133,14 +148,34 @@ def change_model(new_model: str) -> str:
 {recommended}
 
 🔧 **Current Model:** `{current_model}` (unchanged)"""
+            elif "api" in error_str.lower() and "key" in error_str.lower():
+                return f"""❌ **API Configuration Error**
+
+🚫 **Error:** There seems to be an issue with your Anthropic API configuration.
+
+💡 **Please check:**
+- Your ANTHROPIC_API_KEY environment variable is set
+- Your API key is valid and has the necessary permissions
+- Your account has access to the requested model
+
+📝 **Error Details:** {clean_error}
+
+🔧 **Current Model:** `{current_model}` (unchanged)
+
+💡 **Tip:** Try using an OpenAI model if Anthropic models are not working."""
             else:
                 return f"""❌ **Model Error**
 
 🚫 **Error:** Failed to initialize model `{new_model}`
 
-📝 **Details:** {str(model_error)}
+📝 **Error Type:** {error_type}
+📝 **Details:** {clean_error}
 
-🔧 **Current Model:** `{current_model}` (unchanged)"""
+🔧 **Current Model:** `{current_model}` (unchanged)
+
+💡 **Debugging Info:**
+- Provider: {"Anthropic" if "claude" in new_model else "OpenAI" if any(x in new_model for x in ["gpt", "o1", "o3"]) else "Unknown"}
+- Try using a different model or check your API configuration"""
         
         # Reset agent to force recreation with new model
         current_agent = None
@@ -163,6 +198,83 @@ def change_model(new_model: str) -> str:
         return f"❌ **Unexpected Error:** {str(e)}"
 
 
+def filter_model_table(filter_choice: str) -> list:
+    """Filter the model table based on user selection."""
+    all_data = FitnessAgent.get_models_table_data()
+    
+    if filter_choice == "🔵 Anthropic Only":
+        return [row for row in all_data if "🔵 Anthropic" in row[1]]
+    elif filter_choice == "🟢 OpenAI Only":
+        return [row for row in all_data if "🟢 OpenAI" in row[1]]
+    elif filter_choice == "⭐ Recommended Only":
+        return [row for row in all_data if row[0] == "⭐"]
+    else:  # All Models
+        return all_data
+
+
+def select_model_from_table(table_data, evt: gr.SelectData):
+    """Select a model from the table"""
+    try:
+        if evt is None:
+            return "", "Please select a model from the table"
+        
+        # Get the selected row index
+        row_index = evt.index[0] if evt.index else 0
+        
+        # Handle both DataFrame and list formats
+        try:
+            # Try pandas DataFrame access first
+            if hasattr(table_data, 'iloc') and row_index < len(table_data):
+                row = table_data.iloc[row_index]
+                if len(row) >= 7:
+                    rating = row.iloc[0]  # Recommendation star
+                    provider = row.iloc[1]  # Provider
+                    selected_model = row.iloc[2]  # Model name
+                    capability = row.iloc[3]  # Capability rating
+                    speed = row.iloc[4]  # Speed rating
+                    cost = row.iloc[5]  # Cost rating
+                    description = row.iloc[6]  # Description
+                else:
+                    return "", "Invalid table row - insufficient columns"
+            # Fall back to list access
+            elif isinstance(table_data, list) and row_index < len(table_data) and len(table_data[row_index]) >= 7:
+                rating = table_data[row_index][0]  # Recommendation star
+                provider = table_data[row_index][1]  # Provider
+                selected_model = table_data[row_index][2]  # Model name
+                capability = table_data[row_index][3]  # Capability rating
+                speed = table_data[row_index][4]  # Speed rating
+                cost = table_data[row_index][5]  # Cost rating
+                description = table_data[row_index][6]  # Description
+            else:
+                return "", "Invalid selection - please try clicking on a model row"
+                
+        except (IndexError, KeyError) as data_error:
+            logger.error(f"Data access error: {str(data_error)} - Table type: {type(table_data)}, Row index: {row_index}")
+            return "", "Error accessing table data - please try again"
+        
+        # Update the model and get the change result
+        change_result = change_model(selected_model)
+        
+        if "✅" in change_result:
+            model_info = f"""✅ **Model Successfully Selected!**
+
+🤖 **Current Model:** `{selected_model}`
+{provider}
+**Capability:** {capability} | **Speed:** {speed} | **Cost:** {cost}
+
+💡 **Description:** {description}
+
+📊 **Status:** Ready to chat with the new model!"""
+        else:
+            model_info = change_result  # Show the error message
+        
+        return selected_model, model_info
+        
+    except Exception as e:
+        logger.error(f"Error in select_model_from_table: {str(e)} - Table type: {type(table_data)}, Row index: {row_index if 'row_index' in locals() else 'unknown'}")
+        return "", f"Error selecting model: {str(e)}"
+
+
 def update_model_and_display(selected_model: str) -> str:
     """
     Update both the model and the display when dropdown selection changes
@@ -174,10 +286,16 @@ def update_model_and_display(selected_model: str) -> str:
         Formatted model information
     """
     # Ignore separator selections
-    if selected_model == "--- Legacy/Experimental ---":
-        return """⚠️ **Please select a specific model**
+    separators = [
+        "--- Anthropic Models ---", 
+        "--- OpenAI Models ---", 
+        "--- Other Models ---",
+        "--- Legacy/Experimental ---"
+    ]
+    if selected_model in separators:
+        return f"""⚠️ **Please select a specific model**
 
-The separator "--- Legacy/Experimental ---" is not a valid model choice.
+The separator "{selected_model}" is not a valid model choice.
 
 Please choose one of the actual model names from the dropdown."""
     
@@ -188,7 +306,11 @@ Please choose one of the actual model names from the dropdown."""
     if "✅" in change_result:
         try:
             model_info = FitnessAgent.get_model_info(selected_model)
-            return f"""🤖 **Current Model:** `{selected_model}`
+            
+            # Determine provider emoji
+            provider_emoji = "🔵" if "claude" in selected_model else "🟢" if any(x in selected_model for x in ["gpt", "o1", "o3"]) else "⚪"
+            
+            return f"""{provider_emoji} **Current Model:** `{selected_model}`
 
 💡 **Description:** {model_info}
 
@@ -944,27 +1066,41 @@ with gr.Blocks(
     
     # Model selection section
     with gr.Row():
-        with gr.Column(scale=1):
-            # Get available models for dropdown - prioritize recommended models
-            all_models = FitnessAgent.list_supported_models()
-            recommended_models = FitnessAgent.get_recommended_models()
+        with gr.Column():
+            gr.Markdown("### 🤖 AI Model Selection")
+            gr.Markdown("Browse and select your preferred AI model. Click on a row to select it.")
             
-            # Create choices list with recommended models first, then others
-            other_models = [m for m in all_models.keys() if m not in recommended_models]
-            model_choices = recommended_models + ["--- Legacy/Experimental ---"] + other_models
+            # Create model table data
+            table_data = FitnessAgent.get_models_table_data()
             
-            model_dropdown = gr.Dropdown(
-                choices=model_choices,
-                value="claude-3.5-haiku",  # Updated default model
-                label="🤖 AI Model",
-                info="Choose which Anthropic model to use (recommended models listed first)",
-                interactive=True,
-                elem_classes=["model-dropdown"]
+            model_table = gr.DataFrame(
+                value=table_data,
+                headers=["⭐", "Provider", "Model Name", "Capability", "Speed", "Cost", "Description"],
+                datatype=["str", "str", "str", "str", "str", "str", "str"],
+                interactive=False,
+                wrap=True,
+                elem_classes=["model-table"]
             )
+            
+            # Hidden components to manage selection
+            selected_model = gr.Textbox(
+                value="claude-3.5-haiku",
+                visible=False,
+                label="Selected Model"
+            )
+            
+            # Model selection button
+            with gr.Row():
+                model_filter = gr.Dropdown(
+                    choices=["All Models", "🔵 Anthropic Only", "🟢 OpenAI Only", "⭐ Recommended Only"],
+                    value="All Models",
+                    label="Filter Models",
+                    scale=3
+                )
     
     # Model information display
     model_info_display = gr.Markdown(
-        value=f"""🤖 **Current Model:** `claude-3.5-haiku`
+        value=f"""🔵 **Current Model:** `claude-3.5-haiku`
 
 💡 **Description:** {FitnessAgent.get_model_info('claude-3.5-haiku')}
 
@@ -1032,11 +1168,14 @@ with gr.Blocks(
         - Let me know about any injuries or limitations
         
         **AI Model Selection:**
-        - **Claude-4 Models**: Most capable, best for complex reasoning and detailed plans (higher cost)
-        - **Claude-3.5/3.7**: Excellent balance of capability and speed (recommended for most users)
-        - **Claude-3 Haiku**: Fastest and most cost-effective (good for simple questions)
-        - **Claude-2/Instant**: Previous generation models (basic functionality)
+        - **🔵 Anthropic Claude Models**: Excellent for detailed reasoning and analysis
+          - Claude-4: Most capable (premium), Claude-3.7: Extended thinking
+          - Claude-3.5: Balanced performance, Claude-3: Fast and cost-effective
+        - **🟢 OpenAI GPT Models**: Great for general tasks and familiar interface
+          - GPT-4o: Latest with vision, GPT-4 Turbo: Large context window
+          - GPT-3.5: Fast and economical, o1/o3: Advanced reasoning
         - You can change models anytime - the conversation continues seamlessly
+        - Mix and match providers based on your preferences
         
         **Conversation Management:**
         - The assistant remembers our entire conversation
@@ -1054,24 +1193,40 @@ with gr.Blocks(
     
     # Add model comparison section
     with gr.Accordion("🤖 Model Comparison Guide", open=False):
-        model_comparison = "| Model | Capability | Speed | Cost | Best For |\n"
-        model_comparison += "|-------|------------|--------|------|----------|\n"
-        
-        models_info = {
-            "claude-4-opus": ("★★★★★", "★★★☆☆", "★★★★★", "Complex analysis, detailed plans"),
-            "claude-4-sonnet": ("★★★★☆", "★★★★☆", "★★★★☆", "Balanced performance"),
-            "claude-3.7-sonnet": ("★★★★☆", "★★★★☆", "★★★☆☆", "Enhanced capabilities"),
-            "claude-3.5-sonnet": ("★★★★☆", "★★★★☆", "★★★☆☆", "General use, balanced"),
-            "claude-3-opus": ("★★★★☆", "★★★☆☆", "★★★★☆", "Complex tasks"),
-            "claude-3-sonnet": ("★★★☆☆", "★★★★☆", "★★★☆☆", "Standard tasks"),
-            "claude-3-haiku": ("★★★☆☆", "★★★★★", "★★☆☆☆", "Quick questions, cost-effective"),
-            "claude-2.1": ("★★☆☆☆", "★★★★☆", "★★☆☆☆", "Basic functionality"),
-        }
-        
-        for model, (capability, speed, cost, best_for) in models_info.items():
-            model_comparison += f"| {model} | {capability} | {speed} | {cost} | {best_for} |\n"
-        
-        gr.Markdown(model_comparison)
+        gr.Markdown("""
+        ## 🔵 Anthropic Claude Models
+        
+        | Model | Capability | Speed | Cost | Best For |
+        |-------|------------|--------|------|----------|
+        | claude-4-opus | ★★★★★ | ★★★☆☆ | ★★★★★ | Complex analysis, detailed plans |
+        | claude-4-sonnet | ★★★★☆ | ★★★★☆ | ★★★★☆ | Balanced high performance |
+        | claude-3.7-sonnet | ★★★★☆ | ★★★★☆ | ★★★☆☆ | Extended thinking, complex tasks |
+        | claude-3.5-sonnet | ★★★★☆ | ★★★★☆ | ★★★☆☆ | General use, balanced |
+        | claude-3.5-haiku | ★★★☆☆ | ★★★★★ | ★★☆☆☆ | **DEFAULT** - Fast responses |
+        | claude-3-haiku | ★★★☆☆ | ★★★★★ | ★☆☆☆☆ | Most cost-effective |
+        
+        ## 🟢 OpenAI GPT Models
+        
+        | Model | Capability | Speed | Cost | Best For |
+        |-------|------------|--------|------|----------|
+        | gpt-4o | ★★★★★ | ★★★★☆ | ★★★★☆ | Latest features, vision support |
+        | gpt-4o-mini | ★★★★☆ | ★★★★★ | ★★☆☆☆ | Balanced performance, affordable |
+        | gpt-4-turbo | ★★★★☆ | ★★★★☆ | ★★★★☆ | Large context, reliable |
+        | gpt-3.5-turbo | ★★★☆☆ | ★★★★★ | ★☆☆☆☆ | Fast and economical |
+        | o1-preview | ★★★★★ | ★★☆☆☆ | ★★★★★ | Advanced reasoning |
+        | o1-mini | ★★★★☆ | ★★★☆☆ | ★★★☆☆ | Reasoning tasks |
+        | o3-mini | ★★★★☆ | ★★★★☆ | ★★★☆☆ | Latest reasoning model |
+        
+        ### 💡 Provider Comparison
+        - **🔵 Anthropic**: Excellent for detailed analysis, safety-focused, great for complex fitness planning
+        - **🟢 OpenAI**: Familiar interface, good general performance, strong tool usage
+        
+        ### 🎯 Recommendations by Use Case
+        - **Quick questions**: claude-3.5-haiku, gpt-4o-mini, gpt-3.5-turbo
+        - **Comprehensive plans**: claude-3.5-sonnet, gpt-4o, claude-3.7-sonnet
+        - **Complex analysis**: claude-4-opus, gpt-4o, o1-preview
+        - **Budget-conscious**: claude-3-haiku, gpt-3.5-turbo, gpt-4o-mini
+        """)
 
     # Event handlers
     chat_msg = chat_input.submit(
@@ -1079,17 +1234,24 @@ with gr.Blocks(
     )
     bot_msg = chat_msg.then(
         dynamic_bot, 
-        [chatbot, streaming_toggle, model_dropdown], 
+        [chatbot, streaming_toggle, selected_model], 
         chatbot, 
         api_name="bot_response"
     )
     bot_msg.then(lambda: gr.MultimodalTextbox(interactive=True), None, [chat_input])
 
-    # Update model and display when dropdown selection changes
-    model_dropdown.change(
-        update_model_and_display,
-        inputs=[model_dropdown],
-        outputs=[model_info_display]
+    # Model table filtering
+    model_filter.change(
+        filter_model_table,
+        inputs=[model_filter],
+        outputs=[model_table]
+    )
+    
+    # Model selection from table
+    model_table.select(
+        select_model_from_table,
+        inputs=[model_table],
+        outputs=[selected_model, model_info_display]
     )
 
     # Clear conversation handler

fitness_agent/examples.py

@@ -1,7 +1,8 @@
 """
-Example usage of the Fitness Agent with different Anthropic models.
+Example usage of the Fitness Agent with different AI providers and models.
 
-Run this script to see different ways to use the FitnessAgent.
+Run this script to see different ways to use the FitnessAgent with both
+Anthropic Claude and OpenAI GPT models.
 """
 
 from fitness_agent import FitnessAgent
@@ -13,59 +14,133 @@ def basic_example():
     print("=== Basic Usage (Default Model) ===")
     agent = FitnessAgent()
     print(f"Using model: {agent.model_name}")
+    print(f"Provider: {agent.provider}")
+    print(f"Final model path: {agent.final_model}")
     
     # In a real scenario, you would run this:
     # result = Runner.run_sync(agent, "Create a beginner fitness plan.")
     # print(f"Result: {result.final_output}")
-    print("Agent created successfully!")
+    print("✅ Agent created successfully!")
     print()
 
-def specific_model_example():
-    """Example using a specific model."""
-    print("=== Using Specific Model ===")
+def anthropic_example():
+    """Example using Anthropic Claude models."""
+    print("=== Anthropic Claude Example ===")
     agent = FitnessAgent("claude-3.5-sonnet")
     print(f"Using model: {agent.model_name}")
-    print("Agent created successfully!")
+    print(f"Provider: {agent.provider}")
+    print(f"Final model path: {agent.final_model}")
+    print("✅ Anthropic agent created successfully!")
+    print()
+
+def openai_example():
+    """Example using OpenAI GPT models."""
+    print("=== OpenAI GPT Example ===")
+    try:
+        agent = FitnessAgent("gpt-4o-mini")
+        print(f"Using model: {agent.model_name}")
+        print(f"Provider: {agent.provider}")
+        print(f"Final model path: {agent.final_model}")
+        print("✅ OpenAI agent created successfully!")
+    except Exception as e:
+        print(f"⚠️ Could not create OpenAI agent: {e}")
+        print("   (Make sure you have OPENAI_API_KEY set in your .env file)")
+    print()
+
+def reasoning_model_example():
+    """Example using OpenAI reasoning models (o1/o3 series)."""
+    print("=== OpenAI Reasoning Model Example ===")
+    try:
+        agent = FitnessAgent("o1-mini")
+        print(f"Using model: {agent.model_name}")
+        print(f"Provider: {agent.provider}")
+        print(f"Final model path: {agent.final_model}")
+        print("✅ Reasoning model agent created successfully!")
+        print("💡 o1-mini is great for complex fitness planning and analysis")
+    except Exception as e:
+        print(f"⚠️ Could not create reasoning model agent: {e}")
+        print("   (o1 models may require special access)")
     print()
 
 def environment_variable_example():
     """Example using environment variable."""
     print("=== Using Environment Variable ===")
     # Set environment variable (in practice, this would be in your .env file)
-    os.environ["ANTHROPIC_MODEL"] = "claude-3.7-sonnet"
+    os.environ["AI_MODEL"] = "gpt-4o"
     
     agent = FitnessAgent()  # Will use the model from environment variable
     print(f"Using model: {agent.model_name}")
-    print("Agent created successfully!")
+    print(f"Provider: {agent.provider}")
+    print("✅ Agent created with environment variable!")
     print()
 
 def list_available_models():
-    """Display all available models."""
-    print("=== Available Models ===")
-    models = FitnessAgent.list_supported_models()
+    """Display all available models organized by provider."""
+    print("=== Available Models by Provider ===")
     
-    print("Recommended models:")
-    for model in FitnessAgent.get_recommended_models():
-        full_name = models.get(model, "Not found")
+    providers = FitnessAgent.get_models_by_provider()
+    
+    print("🔵 ANTHROPIC MODELS:")
+    for model in providers["anthropic"]:
+        full_name = providers["anthropic"][model]
+        info = FitnessAgent.get_model_info(model)
+        print(f"  • {model}")
+        print(f"    Path: {full_name}")
+        print(f"    Info: {info}")
+        print()
+    
+    print("🟢 OPENAI MODELS:")
+    for model in providers["openai"]:
+        full_name = providers["openai"][model]
         info = FitnessAgent.get_model_info(model)
-        print(f"  • {model}: {full_name}")
-        print(f"    {info}")
+        print(f"  • {model}")
+        print(f"    Path: {full_name}")
+        print(f"    Info: {info}")
         print()
     
-    print("All available models:")
-    for name, full_id in models.items():
-        print(f"  • {name}: {full_id}")
+    print("🎯 RECOMMENDED MODELS:")
+    for model in FitnessAgent.get_recommended_models():
+        provider_icon = "🔵" if "claude" in model else "🟢" if any(x in model for x in ["gpt", "o1", "o3"]) else "⚪"
+        print(f"  {provider_icon} {model}")
+    print()
+
+def compare_providers():
+    """Show comparison between providers."""
+    print("=== Provider Comparison ===")
+    print("🔵 ANTHROPIC CLAUDE:")
+    print("  ✅ Excellent for detailed analysis and safety")
+    print("  ✅ Great context understanding")
+    print("  ✅ Strong reasoning capabilities")
+    print("  ❓ Requires ANTHROPIC_API_KEY")
+    print()
+    
+    print("🟢 OPENAI GPT:")
+    print("  ✅ Familiar and widely used")
+    print("  ✅ Good general performance")
+    print("  ✅ Vision capabilities (GPT-4o)")
+    print("  ✅ Reasoning models (o1/o3 series)")
+    print("  ❓ Requires OPENAI_API_KEY")
     print()
 
 if __name__ == "__main__":
-    print("🤖 Fitness Agent Examples")
-    print("=" * 50)
+    print("🤖 Fitness Agent Examples - Multi-Provider Support")
+    print("=" * 60)
     
     list_available_models()
+    compare_providers()
     basic_example()
-    specific_model_example()
+    anthropic_example()
+    openai_example()
+    reasoning_model_example()
     environment_variable_example()
     
+    print("=" * 60)
     print("✅ All examples completed!")
-    print("\nTo actually run the agent, uncomment the Runner.run_sync lines")
-    print("and make sure you have your ANTHROPIC_API_KEY set in .env")
+    print()
+    print("💡 To actually run the agents:")
+    print("  1. Copy .env.example to .env")
+    print("  2. Add your OPENAI_API_KEY and/or ANTHROPIC_API_KEY")
+    print("  3. Uncomment the Runner.run_sync lines in the examples")
+    print("  4. Run: python fitness_agent/examples.py")
+    print()
+    print("🚀 Or launch the web interface: python fitness_agent/app.py")

fitness_agent/fitness_agent.py

@@ -17,49 +17,78 @@ class FitnessAgent(Agent):
     """
     A helpful assistant for general fitness guidance and handoffs to a plan-building agent.
     
-    Supports current LiteLLM Anthropic models (as of January 2025):
+    Supports multiple AI providers via LiteLLM (as of January 2025):
+    
+    Anthropic models:
     - Claude-4: claude-opus-4-20250514, claude-sonnet-4-20250514 (Premium)
     - Claude-3.7: claude-3-7-sonnet-20250219 (Extended thinking)
     - Claude-3.5: claude-3-5-sonnet-20241022 (latest), claude-3-5-sonnet-20240620 (stable), claude-3-5-haiku-20241022 (fast)
     - Claude-3: claude-3-haiku-20240307 (legacy but reliable)
     
-    Note: Some older models (claude-3-opus, claude-3-sonnet, claude-2.x, claude-instant) 
-    have been deprecated and removed from the API.
+    OpenAI models:
+    - GPT-4o: gpt-4o, gpt-4o-mini (Vision + latest capabilities)
+    - GPT-4: gpt-4-turbo (Legacy but stable)
+    - GPT-3.5: gpt-3.5-turbo (Cost-effective)
+    - Reasoning: o1-preview, o1-mini, o3-mini (Advanced reasoning)
+    
+    Note: Some older models may be deprecated. Always check provider documentation.
     """
 
-    # Available Anthropic models via LiteLLM
-    # Updated to match current Anthropic API as of January 2025
+    # Available models via LiteLLM and native OpenAI
+    # Updated to include both Anthropic and OpenAI models as of January 2025
     SUPPORTED_MODELS = {
+        # === ANTHROPIC MODELS (via LiteLLM) ===
         # Claude-4 models (latest generation - may require special access)
-        "claude-4-opus": "claude-opus-4-20250514",
-        "claude-4-sonnet": "claude-sonnet-4-20250514",
+        "claude-4-opus": "litellm/anthropic/claude-opus-4-20250514",
+        "claude-4-sonnet": "litellm/anthropic/claude-sonnet-4-20250514",
         
         # Claude-3.7 models (newest stable)
-        "claude-3.7-sonnet": "claude-3-7-sonnet-20250219",
+        "claude-3.7-sonnet": "litellm/anthropic/claude-3-7-sonnet-20250219",
         
         # Claude-3.5 models (widely available)
-        "claude-3.5-sonnet-latest": "claude-3-5-sonnet-20241022",  # Latest version
-        "claude-3.5-sonnet": "claude-3-5-sonnet-20240620",        # Previous stable version
-        "claude-3.5-haiku": "claude-3-5-haiku-20241022",          # New Haiku 3.5 model
+        "claude-3.5-sonnet-latest": "litellm/anthropic/claude-3-5-sonnet-20241022",  # Latest version
+        "claude-3.5-sonnet": "litellm/anthropic/claude-3-5-sonnet-20240620",        # Previous stable version
+        "claude-3.5-haiku": "litellm/anthropic/claude-3-5-haiku-20241022",          # New Haiku 3.5 model
         
         # Claude-3 models (legacy but still available)
-        "claude-3-haiku": "claude-3-haiku-20240307",
-        # Note: claude-3-opus and claude-3-sonnet have been deprecated/removed
+        "claude-3-haiku": "litellm/anthropic/claude-3-haiku-20240307",
+        
+        # === OPENAI MODELS (native) ===
+        # GPT-4o models (latest generation with vision)
+        "gpt-4o": "gpt-4o",                                     # Latest GPT-4o model
+        "gpt-4o-mini": "gpt-4o-mini",                          # Compact version
+        
+        # GPT-4 models (previous generation)
+        "gpt-4-turbo": "gpt-4-turbo",                          # Latest GPT-4 Turbo
+        "gpt-4": "gpt-4",                                      # Original GPT-4
+        
+        # GPT-3.5 models (cost-effective)
+        "gpt-3.5-turbo": "gpt-3.5-turbo",                     # Latest 3.5 turbo
+        
+        # Reasoning models (o-series)
+        "o1-preview": "o1-preview",                            # Advanced reasoning
+        "o1-mini": "o1-mini",                                  # Compact reasoning
+        "o3-mini": "o3-mini",                                  # Latest reasoning model
     }
 
     def __init__(self, model_name: Optional[str] = None):
         """
-        Initialize the Fitness Agent with configurable Anthropic model.
+        Initialize the Fitness Agent with configurable AI model (Anthropic or OpenAI).
         
         Args:
-            model_name: Name of the Anthropic model to use. Can be a key from SUPPORTED_MODELS
-                       or a full model identifier. Defaults to claude-3-haiku if not specified.
-                       Can also be set via ANTHROPIC_MODEL environment variable.
+            model_name: Name of the AI model to use. Can be a key from SUPPORTED_MODELS
+                       or a full model identifier. Defaults to claude-3.5-haiku if not specified.
+                       Can also be set via AI_MODEL, ANTHROPIC_MODEL, or OPENAI_MODEL environment variables.
         """
         # Determine which model to use
         if model_name is None:
-            # Check environment variable first, default to the newest fast model
-            model_name = os.getenv("ANTHROPIC_MODEL", "claude-3.5-haiku")
+            # Check environment variables in priority order
+            model_name = (
+                os.getenv("AI_MODEL") or 
+                os.getenv("ANTHROPIC_MODEL") or 
+                os.getenv("OPENAI_MODEL") or 
+                "claude-3.5-haiku"  # Default fallback
+            )
         
         # Validate the model name
         is_valid, validation_message = self.validate_model_name(model_name)
@@ -75,27 +104,30 @@ class FitnessAgent(Agent):
             # Assume it's already a full model identifier
             full_model_name = model_name
         
-        # Add litellm/anthropic/ prefix if not already present
-        if not full_model_name.startswith("litellm/anthropic/"):
-            litellm_model = f"litellm/anthropic/{full_model_name}"
+        # Determine if this is an OpenAI model or needs LiteLLM prefix
+        if self._is_openai_model(model_name, full_model_name):
+            # Use native OpenAI model (no prefix needed)
+            final_model = full_model_name
         else:
-            litellm_model = full_model_name
+            # For Anthropic models, use the full model name as-is since it already has litellm/ prefix
+            final_model = full_model_name
 
         # Store the model information for debugging
         self.model_name = model_name
         self.full_model_name = full_model_name
-        self.litellm_model = litellm_model
+        self.final_model = final_model
+        self.provider = self._get_provider(model_name, full_model_name)
 
         fitness_plan_agent = Agent(
             name="Fitness Plan Assistant",
             instructions="You are a helpful assistant for creating personalized fitness plans.",
-            model=litellm_model,
+            model=final_model,
             output_type=FitnessPlan
         )
 
         super().__init__(
             name="Fitness Assistant",
-            model=litellm_model,
+            model=final_model,
             instructions="""
             You are a helpful assistant for fitness-related queries.
             
@@ -104,6 +136,30 @@ class FitnessAgent(Agent):
             handoffs=[fitness_plan_agent]
         )
 
+    def _is_openai_model(self, model_name: str, full_model_name: str) -> bool:
+        """Check if this is an OpenAI model that should use native API."""
+        # Check direct model name matches
+        openai_models = ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo", "o1-preview", "o1-mini", "o3-mini"]
+        if model_name in openai_models:
+            return True
+        
+        # Check for OpenAI indicators in model names
+        openai_prefixes = ["gpt-", "o1-", "o3-", "openai/", "litellm/openai/"]
+        for prefix in openai_prefixes:
+            if prefix in model_name.lower() or prefix in full_model_name.lower():
+                return True
+        
+        return False
+    
+    def _get_provider(self, model_name: str, full_model_name: str) -> str:
+        """Determine the provider based on the model."""
+        if self._is_openai_model(model_name, full_model_name):
+            return "openai"
+        elif "claude" in model_name.lower() or "anthropic" in full_model_name.lower():
+            return "anthropic"
+        else:
+            return "unknown"
+
     @classmethod
     def list_supported_models(cls) -> dict:
         """Return a dictionary of supported model names and their full identifiers."""
@@ -113,13 +169,24 @@ class FitnessAgent(Agent):
     def get_model_info(cls, model_name: str) -> str:
         """Get information about a specific model."""
         model_info = {
+            # === ANTHROPIC MODELS ===
             "claude-4-opus": "Most capable and intelligent model. Superior reasoning, complex tasks (Premium tier)",
-            "claude-4-sonnet": "High-performance model with exceptional reasoning and efficiency (Premium tier)",
+            "claude-4-sonnet": "High-performance model with exceptional reasoning and efficiency (Premium tier)", 
             "claude-3.7-sonnet": "Enhanced model with extended thinking capabilities (Recommended)",
             "claude-3.5-sonnet-latest": "Latest Claude 3.5 Sonnet with improved capabilities (Recommended)",
             "claude-3.5-sonnet": "Excellent balance of intelligence and speed (Stable version)",
             "claude-3.5-haiku": "Fast and compact model for near-instant responsiveness (New!)",
             "claude-3-haiku": "Fastest model, good for simple tasks and cost-effective (Legacy but reliable)",
+            
+            # === OPENAI MODELS ===
+            "gpt-4o": "Latest GPT-4o with vision, web browsing, and advanced capabilities (Recommended)",
+            "gpt-4o-mini": "Compact GPT-4o model - fast, capable, and cost-effective (Recommended)",
+            "gpt-4-turbo": "GPT-4 Turbo with large context window and improved efficiency",
+            "gpt-4": "Original GPT-4 model - highly capable but slower than turbo variants",
+            "gpt-3.5-turbo": "Fast and cost-effective model, good for straightforward tasks",
+            "o1-preview": "Advanced reasoning model with enhanced problem-solving (Preview)",
+            "o1-mini": "Compact reasoning model for faster inference with good capabilities",
+            "o3-mini": "Latest reasoning model with improved performance (New!)",
         }
         return model_info.get(model_name, "Model information not available")
 
@@ -127,13 +194,128 @@ class FitnessAgent(Agent):
     def get_recommended_models(cls) -> list:
         """Get a list of recommended models that are most likely to be available."""
         return [
-            "claude-3-haiku",           # Most reliable, widely available, cost-effective
-            "claude-3.5-haiku",        # New fast model
+            # Anthropic recommendations (most reliable first)
+            "claude-3.5-haiku",        # New fast model, default
+            "claude-3-haiku",          # Most reliable, widely available, cost-effective
             "claude-3.5-sonnet",       # Stable version, widely available
             "claude-3.5-sonnet-latest", # Latest improvements
             "claude-3.7-sonnet",       # Newest stable with extended thinking
+            
+            # OpenAI recommendations  
+            "gpt-4o-mini",             # Best balance of capability and cost
+            "gpt-4o",                  # Latest flagship model
+            "gpt-3.5-turbo",          # Most cost-effective OpenAI model
+            "gpt-4-turbo",            # Solid previous generation
+            "o1-mini",                # Good reasoning capabilities
         ]
 
+    @classmethod 
+    def get_models_by_provider(cls) -> dict:
+        """Get models organized by provider."""
+        models = cls.list_supported_models()
+        providers = {
+            "anthropic": {},
+            "openai": {},
+            "unknown": {}
+        }
+        
+        for name, full_name in models.items():
+            if "claude" in name.lower() or "anthropic" in full_name.lower():
+                providers["anthropic"][name] = full_name
+            elif any(indicator in name.lower() for indicator in ["gpt-", "o1-", "o3-", "openai/"]):
+                providers["openai"][name] = full_name
+            else:
+                providers["unknown"][name] = full_name
+                
+        return providers
+
+    @classmethod
+    def get_models_table_data(cls) -> list:
+        """Get model data formatted for table display."""
+        models = cls.list_supported_models()
+        table_data = []
+        
+        # Define capability ratings
+        capability_ratings = {
+            # Anthropic models
+            "claude-4-opus": "★★★★★",
+            "claude-4-sonnet": "★★★★☆", 
+            "claude-3.7-sonnet": "★★★★☆",
+            "claude-3.5-sonnet-latest": "★★★★☆",
+            "claude-3.5-sonnet": "★★★★☆",
+            "claude-3.5-haiku": "★★★☆☆",
+            "claude-3-haiku": "★★★☆☆",
+            # OpenAI models
+            "gpt-4o": "★★★★★",
+            "gpt-4o-mini": "★★★★☆",
+            "gpt-4-turbo": "★★★★☆",
+            "gpt-4": "★★★★☆",
+            "gpt-3.5-turbo": "★★★☆☆",
+            "o1-preview": "★★★★★",
+            "o1-mini": "★★★★☆",
+            "o3-mini": "★★★★☆",
+        }
+        
+        # Define speed ratings
+        speed_ratings = {
+            # Anthropic models
+            "claude-4-opus": "★★★☆☆",
+            "claude-4-sonnet": "★★★★☆", 
+            "claude-3.7-sonnet": "★★★★☆",
+            "claude-3.5-sonnet-latest": "★★★★☆",
+            "claude-3.5-sonnet": "★★★★☆",
+            "claude-3.5-haiku": "★★★★★",
+            "claude-3-haiku": "★★★★★",
+            # OpenAI models
+            "gpt-4o": "★★★★☆",
+            "gpt-4o-mini": "★★★★★",
+            "gpt-4-turbo": "★★★★☆",
+            "gpt-4": "★★★☆☆",
+            "gpt-3.5-turbo": "★★★★★",
+            "o1-preview": "★★☆☆☆",
+            "o1-mini": "★★★☆☆",
+            "o3-mini": "★★★★☆",
+        }
+        
+        # Define cost ratings (more stars = more expensive)
+        cost_ratings = {
+            # Anthropic models
+            "claude-4-opus": "★★★★★",
+            "claude-4-sonnet": "★★★★☆", 
+            "claude-3.7-sonnet": "★★★☆☆",
+            "claude-3.5-sonnet-latest": "★★★☆☆",
+            "claude-3.5-sonnet": "★★★☆☆",
+            "claude-3.5-haiku": "★★☆☆☆",
+            "claude-3-haiku": "★☆☆☆☆",
+            # OpenAI models
+            "gpt-4o": "★★★★☆",
+            "gpt-4o-mini": "★★☆☆☆",
+            "gpt-4-turbo": "★★★★☆",
+            "gpt-4": "★★★★☆",
+            "gpt-3.5-turbo": "★☆☆☆☆",
+            "o1-preview": "★★★★★",
+            "o1-mini": "★★★☆☆",
+            "o3-mini": "★★★☆☆",
+        }
+        
+        recommended = cls.get_recommended_models()
+        
+        for model_name, full_path in models.items():
+            provider = "🔵 Anthropic" if "claude" in model_name.lower() else "🟢 OpenAI"
+            is_recommended = "⭐" if model_name in recommended else ""
+            
+            table_data.append([
+                is_recommended,
+                provider,
+                model_name,
+                capability_ratings.get(model_name, "★★★☆☆"),
+                speed_ratings.get(model_name, "★★★☆☆"),
+                cost_ratings.get(model_name, "★★★☆☆"),
+                cls.get_model_info(model_name)
+            ])
+        
+        return table_data
+
     @classmethod
     def validate_model_name(cls, model_name: str) -> tuple[bool, str]:
         """
@@ -154,20 +336,59 @@ class FitnessAgent(Agent):
 
 if __name__ == "__main__":
     # Example usage with different models
-    print("Available Anthropic models:")
-    for name, full_id in FitnessAgent.list_supported_models().items():
-        print(f"  {name}: {full_id}")
+    print("🤖 Available AI Models (Anthropic + OpenAI):")
+    print("=" * 60)
+    
+    # Show models by provider
+    providers = FitnessAgent.get_models_by_provider()
+    
+    print("🔵 ANTHROPIC MODELS:")
+    for name, full_id in providers["anthropic"].items():
+        print(f"  • {name}: {full_id}")
+        print(f"    {FitnessAgent.get_model_info(name)}")
+        print()
+    
+    print("🟢 OPENAI MODELS:")
+    for name, full_id in providers["openai"].items():
+        print(f"  • {name}: {full_id}")
         print(f"    {FitnessAgent.get_model_info(name)}")
+        print()
+    
+    print("🎯 RECOMMENDED MODELS (most likely to work):")
+    recommended = FitnessAgent.get_recommended_models()
+    for model in recommended:
+        provider_icon = "🔵" if "claude" in model else "🟢" if any(x in model for x in ["gpt", "o1", "o3"]) else "⚪"
+        print(f"  {provider_icon} {model}")
     
-    print("\n" + "="*50 + "\n")
+    print("\n" + "="*60 + "\n")
     
-    # Create agent with new default model (claude-3.5-haiku)
-    print("Creating agent with new default model (claude-3.5-haiku)...")
+    # Create agent with default model
+    print("Creating agent with default model (claude-3.5-haiku)...")
     agent = FitnessAgent()
+    print(f"✅ Created agent:")
+    print(f"   Model name: {agent.model_name}")
+    print(f"   Provider: {agent.provider}")
+    print(f"   Final model: {agent.final_model}")
+    
+    print("\n" + "="*60 + "\n")
+    
+    # Example with OpenAI model
+    print("Creating agent with OpenAI model (gpt-4o-mini)...")
+    try:
+        openai_agent = FitnessAgent("gpt-4o-mini")
+        print(f"✅ Created OpenAI agent:")
+        print(f"   Model name: {openai_agent.model_name}")
+        print(f"   Provider: {openai_agent.provider}")
+        print(f"   Final model: {openai_agent.final_model}")
+    except Exception as e:
+        print(f"⚠️ Could not create OpenAI agent: {e}")
+        print("   (This is normal if you don't have OPENAI_API_KEY set)")
     
-    # You can also specify a different model:
-    # agent = FitnessAgent("claude-3.5-sonnet")  # Using friendly name
-    # agent = FitnessAgent("claude-3-5-sonnet-20241022")  # Using full identifier
+    print("\n💡 To actually run the agents:")
+    print("   - Set ANTHROPIC_API_KEY for Claude models")
+    print("   - Set OPENAI_API_KEY for GPT models")
+    print("   - Use Runner.run_sync(agent, 'your message') to chat")
     
-    result = Runner.run_sync(agent, "Hello. Please make me a fitness plan.")
-    print(result.final_output)
+    # Uncomment this to test with actual API call:
+    # result = Runner.run_sync(agent, "Hello. Please make me a fitness plan.")
+    # print(result.final_output)

fitness_agent/test_openai_models.py

@@ -0,0 +1,151 @@
+"""
+Test script to verify OpenAI model integration with the Fitness Agent.
+This will help identify which models are available and test the integration.
+"""
+
+import sys
+import os
+
+# Add the current directory to Python path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from fitness_agent import FitnessAgent
+
+def test_openai_models():
+    """Test OpenAI model availability and integration"""
+    print("🧪 Testing OpenAI Model Integration")
+    print("=" * 60)
+    
+    # Get OpenAI models specifically
+    providers = FitnessAgent.get_models_by_provider()
+    openai_models = providers["openai"]
+    
+    if not openai_models:
+        print("❌ No OpenAI models found in configuration!")
+        return
+    
+    print("📋 Configured OpenAI Models:")
+    for name, full_id in openai_models.items():
+        info = FitnessAgent.get_model_info(name)
+        print(f"  • {name}: {full_id}")
+        print(f"    {info}")
+        print()
+    
+    # Test recommended OpenAI models
+    recommended = FitnessAgent.get_recommended_models()
+    openai_recommended = [m for m in recommended if any(x in m for x in ["gpt", "o1", "o3"])]
+    
+    print("🎯 Recommended OpenAI Models:")
+    for model in openai_recommended:
+        print(f"  🟢 {model}")
+    
+    print("\n" + "=" * 60)
+    
+    # Test creating agents with different OpenAI models
+    test_models = ["gpt-4o-mini", "gpt-4o", "gpt-3.5-turbo", "o1-mini"]
+    
+    for model in test_models:
+        if model in openai_models:
+            print(f"🚀 Testing agent creation with {model}...")
+            try:
+                agent = FitnessAgent(model)
+                print(f"✅ Successfully created agent:")
+                print(f"   Model name: {agent.model_name}")
+                print(f"   Provider: {agent.provider}")
+                print(f"   Final model: {agent.final_model}")
+                print(f"   Expected format: {openai_models[model]}")
+                
+                # Verify the model format is correct
+                if agent.provider == "openai":
+                    print("✅ Correctly identified as OpenAI model")
+                else:
+                    print(f"⚠️ Provider detection issue: expected 'openai', got '{agent.provider}'")
+                    
+            except Exception as e:
+                print(f"❌ Error creating agent with {model}: {str(e)}")
+                if "api" in str(e).lower() or "key" in str(e).lower():
+                    print("   💡 This might be due to missing OPENAI_API_KEY")
+                
+            print()
+
+def test_model_detection():
+    """Test the model provider detection logic"""
+    print("🔍 Testing Model Provider Detection")
+    print("=" * 60)
+    
+    test_cases = [
+        ("gpt-4o", "openai"),
+        ("gpt-4o-mini", "openai"),
+        ("gpt-3.5-turbo", "openai"), 
+        ("o1-preview", "openai"),
+        ("o3-mini", "openai"),
+        ("claude-3.5-haiku", "anthropic"),
+        ("claude-4-opus", "anthropic"),
+        ("openai/gpt-4o", "openai"),
+    ]
+    
+    for model, expected_provider in test_cases:
+        try:
+            agent = FitnessAgent(model)
+            actual_provider = agent.provider
+            status = "✅" if actual_provider == expected_provider else "❌"
+            print(f"{status} {model}: expected {expected_provider}, got {actual_provider}")
+        except Exception as e:
+            print(f"❌ {model}: Error - {str(e)}")
+
+def check_environment():
+    """Check environment setup for OpenAI"""
+    print("\n🔧 Environment Check")
+    print("=" * 60)
+    
+    openai_key = os.getenv("OPENAI_API_KEY")
+    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
+    ai_model = os.getenv("AI_MODEL")
+    
+    print(f"OPENAI_API_KEY: {'✅ Set' if openai_key else '❌ Not set'}")
+    print(f"ANTHROPIC_API_KEY: {'✅ Set' if anthropic_key else '❌ Not set'}")
+    print(f"AI_MODEL: {ai_model if ai_model else 'Not set (will use default)'}")
+    
+    if not openai_key and not anthropic_key:
+        print("\n⚠️ No API keys found! Set at least one in your .env file:")
+        print("   OPENAI_API_KEY=your_openai_key_here")
+        print("   ANTHROPIC_API_KEY=your_anthropic_key_here")
+    elif openai_key and not anthropic_key:
+        print("\n🟢 OpenAI setup detected - you can use GPT models")
+    elif anthropic_key and not openai_key:
+        print("\n🔵 Anthropic setup detected - you can use Claude models")
+    else:
+        print("\n🎉 Both providers configured - you can use all models!")
+
+def show_usage_examples():
+    """Show examples of how to use OpenAI models"""
+    print("\n📚 Usage Examples")
+    print("=" * 60)
+    
+    examples = [
+        ("Basic OpenAI", "FitnessAgent('gpt-4o-mini')"),
+        ("Latest GPT-4o", "FitnessAgent('gpt-4o')"),
+        ("Cost-effective", "FitnessAgent('gpt-3.5-turbo')"),
+        ("Reasoning", "FitnessAgent('o1-mini')"),
+        ("Environment var", "os.environ['AI_MODEL'] = 'gpt-4o'; FitnessAgent()"),
+        ("Via prefix", "FitnessAgent('openai/gpt-4o-mini')"),
+    ]
+    
+    for name, code in examples:
+        print(f"# {name}")
+        print(f"agent = {code}")
+        print()
+
+if __name__ == "__main__":
+    check_environment()
+    test_openai_models()
+    test_model_detection()
+    show_usage_examples()
+    
+    print("=" * 60)
+    print("🎯 Summary:")
+    print("  • OpenAI models are now supported alongside Anthropic")
+    print("  • Use gpt-4o-mini for balanced performance")
+    print("  • Use claude-3.5-haiku for fast responses")
+    print("  • Set OPENAI_API_KEY and/or ANTHROPIC_API_KEY in .env")
+    print("  • Launch with: python app.py")