Spaces:

sdeery
/

fitness-app

Sleeping

App Files Files Community

github-actions[bot] commited on Jul 27

Commit

3a07545

1 Parent(s): b52102b

🤖 Auto-deploy from GitHub (push) - 7eb8444 - 2025-07-27 15:36:09 UTC

Browse files

Files changed (33) hide show

.env.example +1 -1
README.md +20 -95
README_HF.md +32 -0
apps/gradio-app/README.md +24 -0
apps/gradio-app/requirements.txt +89 -0
apps/gradio-app/src/fitness_gradio/__init__.py +9 -0
apps/gradio-app/src/fitness_gradio/examples/__init__.py +10 -0
apps/gradio-app/src/fitness_gradio/examples/demo.py +134 -0
apps/gradio-app/src/fitness_gradio/main.py +52 -0
apps/gradio-app/src/fitness_gradio/ui/__init__.py +13 -0
apps/gradio-app/src/fitness_gradio/ui/app.py +123 -0
apps/gradio-app/src/fitness_gradio/ui/components.py +139 -0
apps/gradio-app/src/fitness_gradio/ui/handlers.py +384 -0
apps/gradio-app/src/fitness_gradio/ui/styles.py +162 -0
fitness_agent/__init__.py +7 -0
fitness_agent/app.py +60 -1261
fitness_agent/fitness_agent.py +80 -387
requirements.txt +10 -4
shared/README.md +20 -0
shared/requirements.txt +59 -0
shared/src/fitness_core/__init__.py +30 -0
shared/src/fitness_core/agents/__init__.py +15 -0
shared/src/fitness_core/agents/base.py +109 -0
shared/src/fitness_core/agents/models.py +34 -0
shared/src/fitness_core/agents/providers.py +298 -0
shared/src/fitness_core/services/__init__.py +24 -0
shared/src/fitness_core/services/agent_runner.py +246 -0
shared/src/fitness_core/services/conversation.py +93 -0
shared/src/fitness_core/services/exceptions.py +28 -0
shared/src/fitness_core/services/formatters.py +206 -0
shared/src/fitness_core/utils/__init__.py +11 -0
shared/src/fitness_core/utils/config.py +79 -0
shared/src/fitness_core/utils/logging.py +63 -0

.env.example CHANGED Viewed

@@ -14,7 +14,7 @@ ANTHROPIC_API_KEY=your_anthropic_key_here
 # OPENAI_API_KEY=your_openai_api_key_here
 # ANTHROPIC_API_KEY=your_anthropic_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

 # OPENAI_API_KEY=your_openai_api_key_here
 # ANTHROPIC_API_KEY=your_anthropic_key_here
+# Optional: Set default model (will use gpt-4o-mini if not set)
 # AI_MODEL=gpt-4o-mini
 # AI_MODEL=claude-3.5-sonnet
 # AI_MODEL=gpt-4o

README.md CHANGED Viewed

@@ -1,107 +1,32 @@
----
-title: Fitness AI Assistant
-emoji: 🏋️‍♀️
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 5.38.1
-app_file: fitness_agent/app.py
-pinned: false
-license: mit
----
-# 🏋️‍♀️ Fitness AI Assistant
-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
-- **💡 Fitness Guidance**: Expert advice on exercises, form, and best practices
-- **🤖 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
-## 🤖 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
-### Option 1: Run Locally
-```bash
-# Clone the repository
-git clone <your-repo-url>
-cd fitness-app
-# Install dependencies
-pip install -r requirements.txt
-# Set up environment - choose your provider(s)
-cp .env.example .env
-# 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 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
-## 🎯 Example Prompts
-- "Create a beginner workout plan for me"
-- "I want to lose weight - help me with a fitness plan"
-- "Design a muscle building program for intermediate level"
-- "I need a meal plan for gaining muscle mass"
-- "Help me with a home workout routine with no equipment"
-## 🤖 AI Model Options
-| Model | Speed | Capability | Best For |
-|-------|--------|------------|----------|
-| claude-3.5-haiku | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | Quick questions, cost-effective (default) |
-| claude-3.5-sonnet | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | Balanced performance, recommended |
-| claude-3.7-sonnet | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | Extended thinking, complex plans |
-| claude-4-sonnet | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | High performance (premium) |
-| claude-4-opus | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | Maximum capability (premium) |
-## 📚 Documentation
-- **[Complete Model Guide](fitness_agent/COMPLETE_MODEL_GUIDE.md)** - Everything about AI models
-- **[Examples](fitness_agent/examples.py)** - Code examples for different use cases
-- **[Test Script](fitness_agent/test_updated_models.py)** - Test model availability
-## 🛠️ Tech Stack
-- **Backend**: Python, LiteLLM, Anthropic API
-- **Frontend**: Gradio
-- **AI Models**: Anthropic Claude (3.5-Haiku to 4-Opus)
-- **Features**: Real-time streaming, conversation memory, model switching
 ---
-*Built with ❤️ for fitness enthusiasts*
-*Start your fitness journey today with personalized AI guidance!*

+# Fitness AI Assistant
+Your personal AI-powered fitness and nutrition coach built with Gradio.
+## Features
+- **Personalized Fitness Plans**: Get customized workout routines based on your goals and fitness level
+- **Nutrition Guidance**: Receive tailored dietary advice and meal planning suggestions
+- **Progress Tracking**: Monitor your fitness journey with AI-powered insights
+- **Expert Knowledge**: Access evidence-based fitness and nutrition information
+## How to Use
+1. Start a conversation by describing your fitness goals
+2. Ask questions about workouts, nutrition, or health
+3. Get personalized recommendations and guidance
+4. Follow up with specific questions for detailed advice
+## Technology
+This app is built using:
+- **Gradio** for the web interface
+- **OpenAI GPT models** for intelligent conversations
+- **Custom fitness knowledge base** for specialized guidance
+## Getting Started
+Simply type your fitness-related question or goal in the chat interface below!
 ---
+*Note: This AI assistant provides general fitness and nutrition guidance. Always consult with healthcare professionals for medical advice or before starting new exercise programs.*

README_HF.md ADDED Viewed

	@@ -0,0 +1,32 @@

+# Fitness AI Assistant
+Your personal AI-powered fitness and nutrition coach built with Gradio.
+## Features
+- **Personalized Fitness Plans**: Get customized workout routines based on your goals and fitness level
+- **Nutrition Guidance**: Receive tailored dietary advice and meal planning suggestions
+- **Progress Tracking**: Monitor your fitness journey with AI-powered insights
+- **Expert Knowledge**: Access evidence-based fitness and nutrition information
+## How to Use
+1. Start a conversation by describing your fitness goals
+2. Ask questions about workouts, nutrition, or health
+3. Get personalized recommendations and guidance
+4. Follow up with specific questions for detailed advice
+## Technology
+This app is built using:
+- **Gradio** for the web interface
+- **OpenAI GPT models** for intelligent conversations
+- **Custom fitness knowledge base** for specialized guidance
+## Getting Started
+Simply type your fitness-related question or goal in the chat interface below!
+---
+*Note: This AI assistant provides general fitness and nutrition guidance. Always consult with healthcare professionals for medical advice or before starting new exercise programs.*

apps/gradio-app/README.md ADDED Viewed

	@@ -0,0 +1,24 @@

+# Fitness Gradio App
+Web interface for the Fitness AI Assistant using Gradio.
+## Features
+- Interactive chat interface
+- Model selection (OpenAI/Anthropic)
+- Real-time streaming responses
+- Fitness plan generation
+- Mobile-friendly design
+## Running the App
+```bash
+poetry install
+poetry run fitness-gradio
+```
+Or:
+```bash
+poetry run python -m fitness_gradio.main
+```

apps/gradio-app/requirements.txt ADDED Viewed

	@@ -0,0 +1,89 @@

+-e file:///C:/Users/sdeer/OneDrive/Projects/fitness-app/shared ; python_version >= "3.12" and python_version < "4.0"
+aiofiles==24.1.0 ; python_version >= "3.12" and python_version < "4.0"
+aiohappyeyeballs==2.6.1 ; python_version >= "3.12" and python_version < "4.0"
+aiohttp==3.12.14 ; python_version >= "3.12" and python_version < "4.0"
+aiosignal==1.4.0 ; python_version >= "3.12" and python_version < "4.0"
+annotated-types==0.7.0 ; python_version >= "3.12" and python_version < "4.0"
+anyio==4.9.0 ; python_version >= "3.12" and python_version < "4.0"
+attrs==25.3.0 ; python_version >= "3.12" and python_version < "4.0"
+audioop-lts==0.2.1 ; python_version >= "3.13" and python_version < "4.0"
+brotli==1.1.0 ; python_version >= "3.12" and python_version < "4.0"
+certifi==2025.7.14 ; python_version >= "3.12" and python_version < "4.0"
+charset-normalizer==3.4.2 ; python_version >= "3.12" and python_version < "4"
+click==8.2.1 ; python_version >= "3.12" and python_version < "4.0"
+colorama==0.4.6 ; python_version >= "3.12" and python_version < "4.0"
+distro==1.9.0 ; python_version >= "3.12" and python_version < "4.0"
+fastapi==0.116.1 ; python_version >= "3.12" and python_version < "4.0"
+ffmpy==0.6.1 ; python_version >= "3.12" and python_version < "4.0"
+filelock==3.18.0 ; python_version >= "3.12" and python_version < "4.0"
+frozenlist==1.7.0 ; python_version >= "3.12" and python_version < "4.0"
+fsspec==2025.7.0 ; python_version >= "3.12" and python_version < "4.0"
+gradio-client==1.11.0 ; python_version >= "3.12" and python_version < "4.0"
+gradio==5.38.2 ; python_version >= "3.12" and python_version < "4.0"
+griffe==1.8.0 ; python_version >= "3.12" and python_version < "4.0"
+groovy==0.1.2 ; python_version >= "3.12" and python_version < "4.0"
+h11==0.16.0 ; python_version >= "3.12" and python_version < "4.0"
+hf-xet==1.1.5 ; python_version >= "3.12" and python_version < "4.0" and (platform_machine == "x86_64" or platform_machine == "amd64" or platform_machine == "arm64" or platform_machine == "aarch64")
+httpcore==1.0.9 ; python_version >= "3.12" and python_version < "4.0"
+httpx-sse==0.4.1 ; python_version >= "3.12" and python_version < "4.0"
+httpx==0.28.1 ; python_version >= "3.12" and python_version < "4.0"
+huggingface-hub==0.34.1 ; python_version >= "3.12" and python_version < "4.0"
+idna==3.10 ; python_version >= "3.12" and python_version < "4.0"
+importlib-metadata==8.7.0 ; python_version >= "3.12" and python_version < "4.0"
+jinja2==3.1.6 ; python_version >= "3.12" and python_version < "4.0"
+jiter==0.10.0 ; python_version >= "3.12" and python_version < "4.0"
+jsonschema-specifications==2025.4.1 ; python_version >= "3.12" and python_version < "4.0"
+jsonschema==4.25.0 ; python_version >= "3.12" and python_version < "4.0"
+litellm==1.74.8 ; python_version >= "3.12" and python_version < "4.0"
+markdown-it-py==3.0.0 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+markupsafe==3.0.2 ; python_version >= "3.12" and python_version < "4.0"
+mcp==1.12.2 ; python_version >= "3.12" and python_version < "4.0"
+mdurl==0.1.2 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+multidict==6.6.3 ; python_version >= "3.12" and python_version < "4.0"
+numpy==2.3.2 ; python_version >= "3.12" and python_version < "4.0"
+openai-agents[litellm]==0.2.3 ; python_version >= "3.12" and python_version < "4.0"
+openai==1.97.1 ; python_version >= "3.12" and python_version < "4.0"
+orjson==3.11.1 ; python_version >= "3.12" and python_version < "4.0"
+packaging==25.0 ; python_version >= "3.12" and python_version < "4.0"
+pandas==2.3.1 ; python_version >= "3.12" and python_version < "4.0"
+pillow==11.3.0 ; python_version >= "3.12" and python_version < "4.0"
+propcache==0.3.2 ; python_version >= "3.12" and python_version < "4.0"
+pydantic-core==2.33.2 ; python_version >= "3.12" and python_version < "4.0"
+pydantic-settings==2.10.1 ; python_version >= "3.12" and python_version < "4.0"
+pydantic==2.11.7 ; python_version >= "3.12" and python_version < "4.0"
+pydub==0.25.1 ; python_version >= "3.12" and python_version < "4.0"
+pygments==2.19.2 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+python-dateutil==2.9.0.post0 ; python_version >= "3.12" and python_version < "4.0"
+python-dotenv==1.1.1 ; python_version >= "3.12" and python_version < "4.0"
+python-multipart==0.0.20 ; python_version >= "3.12" and python_version < "4.0"
+pytz==2025.2 ; python_version >= "3.12" and python_version < "4.0"
+pywin32==311 ; python_version >= "3.12" and python_version < "4.0" and sys_platform == "win32"
+pyyaml==6.0.2 ; python_version >= "3.12" and python_version < "4.0"
+referencing==0.36.2 ; python_version >= "3.12" and python_version < "4.0"
+regex==2024.11.6 ; python_version >= "3.12" and python_version < "4.0"
+reportlab==4.4.3 ; python_version >= "3.12" and python_version < "4"
+requests==2.32.4 ; python_version >= "3.12" and python_version < "4.0"
+rich==14.1.0 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+rpds-py==0.26.0 ; python_version >= "3.12" and python_version < "4.0"
+ruff==0.12.5 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+safehttpx==0.1.6 ; python_version >= "3.12" and python_version < "4.0"
+semantic-version==2.10.0 ; python_version >= "3.12" and python_version < "4.0"
+shellingham==1.5.4 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+six==1.17.0 ; python_version >= "3.12" and python_version < "4.0"
+sniffio==1.3.1 ; python_version >= "3.12" and python_version < "4.0"
+sse-starlette==3.0.2 ; python_version >= "3.12" and python_version < "4.0"
+starlette==0.47.2 ; python_version >= "3.12" and python_version < "4.0"
+tiktoken==0.9.0 ; python_version >= "3.12" and python_version < "4.0"
+tokenizers==0.21.2 ; python_version >= "3.12" and python_version < "4.0"
+tomlkit==0.13.3 ; python_version >= "3.12" and python_version < "4.0"
+tqdm==4.67.1 ; python_version >= "3.12" and python_version < "4.0"
+typer==0.16.0 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+types-requests==2.32.4.20250611 ; python_version >= "3.12" and python_version < "4.0"
+typing-extensions==4.14.1 ; python_version >= "3.12" and python_version < "4.0"
+typing-inspection==0.4.1 ; python_version >= "3.12" and python_version < "4.0"
+tzdata==2025.2 ; python_version >= "3.12" and python_version < "4.0"
+urllib3==2.5.0 ; python_version >= "3.12" and python_version < "4.0"
+uvicorn==0.35.0 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+websockets==15.0.1 ; python_version >= "3.12" and python_version < "4.0"
+yarl==1.20.1 ; python_version >= "3.12" and python_version < "4.0"
+zipp==3.23.0 ; python_version >= "3.12" and python_version < "4.0"

apps/gradio-app/src/fitness_gradio/__init__.py ADDED Viewed

	@@ -0,0 +1,9 @@

+"""
+Fitness Gradio App - Web interface for the Fitness AI Assistant.
+"""
+__version__ = "0.1.0"
+from .ui import create_fitness_app
+__all__ = ['create_fitness_app']

apps/gradio-app/src/fitness_gradio/examples/__init__.py ADDED Viewed

	@@ -0,0 +1,10 @@

+"""
+Examples module for the fitness app.
+"""
+from .demo import run_examples, example_agent_conversation, example_model_listing
+__all__ = [
+    'run_examples',
+    'example_agent_conversation',
+    'example_model_listing'
+]

apps/gradio-app/src/fitness_gradio/examples/demo.py ADDED Viewed

	@@ -0,0 +1,134 @@

+"""
+Example usage and demonstration of the fitness app.
+"""
+import asyncio
+from agents import Runner
+from ..agents import FitnessAgent
+from ..utils import setup_logging, get_logger
+# Setup logging for examples
+setup_logging()
+logger = get_logger(__name__)
+def example_model_listing():
+    """Example of listing available models."""
+    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}")
+def example_agent_creation():
+    """Example of creating agents with different models."""
+    print("\n" + "="*60 + "\n")
+    # Create agent with default model
+    print("Creating agent with default model (gpt-4o-mini)...")
+    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)")
+async def example_agent_conversation():
+    """Example of having a conversation with the agent."""
+    print("\n" + "="*60)
+    print("🗣️ EXAMPLE CONVERSATION")
+    print("="*60 + "\n")
+    try:
+        # Create agent
+        agent = FitnessAgent()
+        print(f"Using model: {agent.model_name}")
+        print()
+        # Example conversation
+        example_messages = [
+            "Hello! I'm new to fitness and want to start working out.",
+            "I want to build muscle but I only have 30 minutes a day, 3 times a week.",
+            "Can you create a specific workout plan for me?"
+        ]
+        for i, message in enumerate(example_messages, 1):
+            print(f"👤 User (Message {i}): {message}")
+            try:
+                # Run the agent
+                result = Runner.run_sync(agent, message)
+                response = result.final_output
+                print(f"🤖 Assistant: {response}")
+                print("\n" + "-"*40 + "\n")
+            except Exception as e:
+                print(f"❌ Error: {str(e)}")
+                print("   (This is expected if you don't have API keys configured)")
+                break
+    except Exception as e:
+        print(f"❌ Could not create agent: {e}")
+        print("   Make sure you have OPENAI_API_KEY or ANTHROPIC_API_KEY configured")
+def run_examples():
+    """Run all examples."""
+    print("🏋️‍♀️ FITNESS APP EXAMPLES")
+    print("="*60)
+    # Model listing example
+    example_model_listing()
+    # Agent creation example
+    example_agent_creation()
+    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")
+    # Conversation example (commented out by default since it requires API keys)
+    print("\n🔄 To see a conversation example, uncomment the following:")
+    print("   # asyncio.run(example_agent_conversation())")
+    # Uncomment this line to run the conversation example:
+    # asyncio.run(example_agent_conversation())
+if __name__ == "__main__":
+    run_examples()

apps/gradio-app/src/fitness_gradio/main.py ADDED Viewed

	@@ -0,0 +1,52 @@

+"""
+Main entry point for the Gradio fitness app.
+"""
+import sys
+from pathlib import Path
+# Add the shared library to the Python path if needed
+shared_path = Path(__file__).parent.parent.parent.parent / "shared" / "src"
+if str(shared_path) not in sys.path:
+    sys.path.insert(0, str(shared_path))
+from fitness_core import setup_logging, Config, get_logger
+from .ui import create_fitness_app
+# Configure logging
+setup_logging(level=Config.LOG_LEVEL, log_file=Config.LOG_FILE)
+logger = get_logger(__name__)
+def main():
+    """Main entry point for the Gradio application."""
+    try:
+        # Validate configuration
+        config_status = Config.validate_config()
+        if not config_status["valid"]:
+            logger.error("Configuration validation failed:")
+            for error in config_status["errors"]:
+                logger.error(f"  - {error}")
+            sys.exit(1)
+        # Show warnings
+        for warning in config_status["warnings"]:
+            logger.warning(warning)
+        # Create and launch the Gradio app
+        logger.info("🎨 Starting Fitness Gradio App...")
+        app = create_fitness_app()
+        gradio_config = Config.get_gradio_config()
+        logger.info(f"🚀 Launching on http://{gradio_config['server_name']}:{gradio_config['server_port']}")
+        app.launch(**gradio_config)
+    except Exception as e:
+        logger.error(f"Failed to start Gradio app: {str(e)}")
+        sys.exit(1)
+if __name__ == "__main__":
+    main()

apps/gradio-app/src/fitness_gradio/ui/__init__.py ADDED Viewed

	@@ -0,0 +1,13 @@

+"""
+UI components and handlers for the Gradio fitness app.
+"""
+from .app import FitnessAppUI, create_fitness_app
+from .components import UIComponents
+from .handlers import UIHandlers
+__all__ = [
+    'FitnessAppUI',
+    'create_fitness_app',
+    'UIComponents',
+    'UIHandlers'
+]

apps/gradio-app/src/fitness_gradio/ui/app.py ADDED Viewed

	@@ -0,0 +1,123 @@

+"""
+Main Gradio UI application for the fitness app.
+"""
+import gradio as gr
+from typing import Dict, Any
+from .components import UIComponents
+from .handlers import UIHandlers
+from .styles import MAIN_CSS
+from fitness_core.utils import Config, get_logger
+logger = get_logger(__name__)
+class FitnessAppUI:
+    """Main UI application class."""
+    def __init__(self):
+        """Initialize the UI application."""
+        self.demo = None
+        self._setup_interface()
+    def _setup_interface(self) -> None:
+        """Set up the Gradio interface."""
+        with gr.Blocks(
+            theme=gr.themes.Soft(),
+            title="Fitness AI Assistant",
+            css=MAIN_CSS
+        ) as self.demo:
+            # Header
+            UIComponents.create_header()
+            # Model selection section
+            with gr.Row():
+                (model_table, model_filter,
+                 selected_model, model_info_display) = UIComponents.create_model_selection_section()
+            # Main chat interface
+            chatbot = UIComponents.create_chatbot()
+            chat_input = UIComponents.create_chat_input()
+            # Control buttons
+            clear_btn, streaming_toggle = UIComponents.create_control_buttons()
+            # Examples section
+            UIComponents.create_examples_section(chat_input)
+            # Help sections
+            UIComponents.create_help_section()
+            UIComponents.create_model_comparison_section()
+            # Event handlers
+            self._setup_event_handlers(
+                chatbot, chat_input, clear_btn, streaming_toggle,
+                model_table, model_filter, selected_model, model_info_display
+            )
+    def _setup_event_handlers(
+        self,
+        chatbot: gr.Chatbot,
+        chat_input: gr.MultimodalTextbox,
+        clear_btn: gr.Button,
+        streaming_toggle: gr.Checkbox,
+        model_table: gr.DataFrame,
+        model_filter: gr.Dropdown,
+        selected_model: gr.Textbox,
+        model_info_display: gr.Markdown
+    ) -> None:
+        """Set up all event handlers."""
+        # Chat message handling
+        chat_msg = chat_input.submit(
+            UIHandlers.add_message,
+            [chatbot, chat_input],
+            [chatbot, chat_input]
+        )
+        bot_msg = chat_msg.then(
+            UIHandlers.dynamic_bot,
+            [chatbot, streaming_toggle, selected_model],
+            chatbot,
+            api_name="bot_response"
+        )
+        bot_msg.then(lambda: gr.MultimodalTextbox(interactive=True), None, [chat_input])
+        # Model table filtering
+        model_filter.change(
+            UIHandlers.filter_model_table,
+            inputs=[model_filter],
+            outputs=[model_table]
+        )
+        # Model selection from table
+        model_table.select(
+            UIHandlers.select_model_from_table,
+            inputs=[model_table],
+            outputs=[selected_model, model_info_display]
+        )
+        # Clear conversation handler
+        clear_btn.click(UIHandlers.clear_conversation, None, chatbot)
+        # Like/dislike feedback
+        chatbot.like(UIHandlers.print_like_dislike, None, None, like_user_message=True)
+    def launch(self, **kwargs) -> None:
+        """Launch the Gradio app."""
+        # Get default config and merge with provided kwargs
+        config = Config.get_gradio_config()
+        config.update(kwargs)
+        logger.info(f"Launching fitness app UI on {config['server_name']}:{config['server_port']}")
+        self.demo.launch(**config)
+    def get_demo(self) -> gr.Blocks:
+        """Get the Gradio demo object."""
+        return self.demo
+def create_fitness_app() -> gr.Blocks:
+    """Create and return a new fitness app UI instance."""
+    app = FitnessAppUI()
+    return app.get_demo()

apps/gradio-app/src/fitness_gradio/ui/components.py ADDED Viewed

	@@ -0,0 +1,139 @@

+"""
+UI components for the fitness app.
+"""
+import gradio as gr
+from typing import List
+from fitness_core.agents import FitnessAgent
+from .styles import (
+    HEADER_MARKDOWN,
+    HELP_CONTENT,
+    MODEL_COMPARISON_CONTENT,
+    EXAMPLE_PROMPTS
+)
+class UIComponents:
+    """Factory class for creating UI components."""
+    @staticmethod
+    def create_header() -> gr.Markdown:
+        """Create the app header."""
+        return gr.Markdown(HEADER_MARKDOWN)
+    @staticmethod
+    def create_model_selection_section() -> tuple:
+        """
+        Create the model selection section with table and controls.
+        Returns:
+            Tuple of (model_table, model_filter, selected_model, model_info_display)
+        """
+        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 model table data
+            table_data = FitnessAgent.get_models_table_data()
+            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 component to manage selection
+            selected_model = gr.Textbox(
+                value="gpt-4o-mini",
+                visible=False,
+                label="Selected Model"
+            )
+            # Model filter dropdown
+            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:** `gpt-4o-mini`
+💡 **Description:** {FitnessAgent.get_model_info('gpt-4o-mini')}
+📊 **Status:** Ready to chat!""",
+            visible=True,
+            elem_classes=["model-info"]
+        )
+        return model_table, model_filter, selected_model, model_info_display
+    @staticmethod
+    def create_chatbot() -> gr.Chatbot:
+        """Create the main chatbot component."""
+        return gr.Chatbot(
+            elem_id="chatbot",
+            type="messages",
+            show_copy_button=True,
+            show_share_button=False,
+            avatar_images=None,
+            sanitize_html=True,
+            render_markdown=True
+        )
+    @staticmethod
+    def create_chat_input() -> gr.MultimodalTextbox:
+        """Create the chat input component."""
+        return gr.MultimodalTextbox(
+            interactive=True,
+            file_count="multiple",
+            placeholder="Ask me about fitness, request a workout plan, or get meal planning advice...",
+            show_label=False,
+            sources=["microphone", "upload"],
+        )
+    @staticmethod
+    def create_control_buttons() -> tuple:
+        """
+        Create the control buttons (clear, streaming toggle).
+        Returns:
+            Tuple of (clear_btn, streaming_toggle)
+        """
+        with gr.Row():
+            clear_btn = gr.Button("🗑️ Clear Conversation", variant="secondary", size="sm")
+            streaming_toggle = gr.Checkbox(
+                label="🚀 Enable Real-time Streaming",
+                value=True,
+                info="Stream responses in real-time as the agent generates them"
+            )
+        return clear_btn, streaming_toggle
+    @staticmethod
+    def create_examples_section(chat_input: gr.MultimodalTextbox) -> gr.Examples:
+        """Create the examples section."""
+        with gr.Row():
+            return gr.Examples(
+                examples=EXAMPLE_PROMPTS,
+                inputs=chat_input,
+                label="💡 Try asking:"
+            )
+    @staticmethod
+    def create_help_section() -> gr.Accordion:
+        """Create the help accordion section."""
+        with gr.Accordion("ℹ️ How to use this assistant", open=False):
+            gr.Markdown(HELP_CONTENT)
+    @staticmethod
+    def create_model_comparison_section() -> gr.Accordion:
+        """Create the model comparison accordion section."""
+        with gr.Accordion("🤖 Model Comparison Guide", open=False):
+            gr.Markdown(MODEL_COMPARISON_CONTENT)

apps/gradio-app/src/fitness_gradio/ui/handlers.py ADDED Viewed

	@@ -0,0 +1,384 @@

+"""
+Event handlers for the fitness app UI.
+"""
+import gradio as gr
+import logging
+from typing import List, Dict, Union, Generator, Any, Tuple
+from fitness_core.agents import FitnessAgent
+from fitness_core.services import ConversationManager, AgentRunner, ResponseFormatter
+from fitness_core.utils import get_logger
+logger = get_logger(__name__)
+# Global state management
+conversation_manager = ConversationManager()
+current_agent = None
+current_model = "gpt-4o-mini"
+class UIHandlers:
+    """Collection of event handlers for the UI."""
+    @staticmethod
+    def get_or_create_agent(model_name: str = None) -> FitnessAgent:
+        """
+        Get the current agent or create a new one with the specified model
+        Args:
+            model_name: Name of the AI model to use
+        Returns:
+            FitnessAgent instance
+        """
+        global current_agent, current_model
+        # Use default if no model specified
+        if model_name is None:
+            model_name = current_model
+        # Create new agent if model changed or no agent exists
+        if current_agent is None or current_model != model_name:
+            logger.info(f"Creating new agent with model: {model_name}")
+            current_agent = FitnessAgent(model_name)
+            current_model = model_name
+        return current_agent
+    @staticmethod
+    def change_model(new_model: str) -> str:
+        """
+        Change the current model and reset the agent
+        Args:
+            new_model: New model to use
+        Returns:
+            Status message
+        """
+        global current_agent, current_model
+        try:
+            # Validate model exists in our supported list
+            is_valid, validation_message = FitnessAgent.validate_model_name(new_model)
+            if not is_valid:
+                return f"""❌ **Invalid Model Selection**
+{validation_message}
+Please select a model from the supported list above."""
+            # Test if we can create an agent with this model (basic validation)
+            try:
+                test_agent = FitnessAgent(new_model)
+                logger.info(f"Successfully validated model: {new_model}")
+            except Exception as model_error:
+                logger.error(f"Failed to create agent with model {new_model}: {model_error}")
+                return f"""❌ **Model Creation Failed**
+Could not create agent with model `{new_model}`.
+**Error:** {str(model_error)}
+Please check your API keys and try a different model."""
+            # Reset agent to force recreation with new model
+            current_agent = None
+            current_model = new_model
+            # Get model info for user feedback
+            model_info = FitnessAgent.get_model_info(new_model)
+            logger.info(f"Model changed to: {new_model}")
+            return f"""✅ **Model Successfully Changed!**
+🤖 **Current Model:** `{new_model}`
+💡 **Description:** {model_info}
+🔄 **Status:** Ready to chat with the new model. Your conversation history is preserved."""
+        except Exception as e:
+            logger.error(f"Error changing model: {str(e)}")
+            return f"❌ **Unexpected Error:** {str(e)}"
+    @staticmethod
+    def filter_model_table(filter_choice: str) -> List[List[str]]:
+        """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
+    @staticmethod
+    def select_model_from_table(table_data: Any, evt: gr.SelectData) -> Tuple[str, str]:
+        """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 = UIHandlers.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)}"
+    @staticmethod
+    def print_like_dislike(x: gr.LikeData) -> None:
+        """Log user feedback on messages"""
+        logger.info(f"User feedback - Index: {x.index}, Value: {x.value}, Liked: {x.liked}")
+    @staticmethod
+    def add_message(history: List[Dict], message: Dict) -> Tuple[List[Dict], gr.MultimodalTextbox]:
+        """
+        Add user message to chat history with proper validation
+        Args:
+            history: Current Gradio chat history (for display)
+            message: User message containing text and/or files
+        Returns:
+            Tuple of (updated_history, cleared_input)
+        """
+        try:
+            user_content_parts = []
+            # Handle file uploads
+            if message.get("files"):
+                for file_path in message["files"]:
+                    if file_path:  # Validate file path exists
+                        file_content = f"[File uploaded: {file_path}]"
+                        user_content_parts.append(file_content)
+                        # Add to Gradio history for display
+                        history.append({
+                            "role": "user",
+                            "content": {"path": file_path}
+                        })
+            # Handle text input
+            if message.get("text") and message["text"].strip():
+                text_content = message["text"].strip()
+                user_content_parts.append(text_content)
+                # Add to Gradio history for display
+                history.append({
+                    "role": "user",
+                    "content": text_content
+                })
+            # Add to conversation manager (combine file and text content)
+            if user_content_parts:
+                combined_content = "\n".join(user_content_parts)
+                conversation_manager.add_user_message(combined_content)
+                logger.info(f"Added user message to conversation. {conversation_manager.get_history_summary()}")
+            return history, gr.MultimodalTextbox(value=None, interactive=False)
+        except Exception as e:
+            logger.error(f"Error adding message: {str(e)}")
+            # Add error message to history
+            history.append({
+                "role": "assistant",
+                "content": "Sorry, there was an error processing your message. Please try again."
+            })
+            return history, gr.MultimodalTextbox(value=None, interactive=False)
+    @staticmethod
+    def bot_with_real_streaming(
+        history: List[Dict],
+        model_name: str = None
+    ) -> Generator[List[Dict], None, None]:
+        """
+        Bot function with real-time streaming from the agent
+        Args:
+            history: Current Gradio chat history (for display only)
+            model_name: Model to use for the agent
+        Yields:
+            Updated history with real-time streaming response
+        """
+        try:
+            # Get agent instance with specified model
+            agent = UIHandlers.get_or_create_agent(model_name)
+            # Get input for agent from conversation manager
+            agent_input = conversation_manager.get_input_for_agent()
+            logger.info(f"Sending to agent ({current_model}): {type(agent_input)} - {conversation_manager.get_history_summary()}")
+            # Add empty assistant message for streaming
+            history.append({"role": "assistant", "content": ""})
+            # Use the AgentRunner for streaming execution
+            logger.info(f"Using real-time streaming mode")
+            # Direct execution without ThreadPoolExecutor to avoid event loop issues
+            try:
+                content_chunks = []
+                final_result = None
+                for chunk in AgentRunner.run_agent_with_streaming_sync(agent, agent_input):
+                    if chunk['type'] == 'final_result':
+                        final_result = chunk['result']
+                        if chunk['content']:
+                            content_chunks.append(chunk['content'])
+                    elif chunk['type'] == 'error':
+                        final_result = chunk['result']
+                        content_chunks.append(chunk['content'])
+                # Update conversation manager
+                if final_result:
+                    conversation_manager.update_from_result(final_result)
+                    logger.info(f"Updated conversation manager. {conversation_manager.get_history_summary()}")
+                # Stream the content updates to the UI
+                if content_chunks:
+                    for content in content_chunks:
+                        history[-1]["content"] = content
+                        yield history
+                else:
+                    history[-1]["content"] = "I apologize, but I didn't receive a response. Please try again."
+                    yield history
+            except Exception as e:
+                logger.error(f"Error in streaming execution: {str(e)}")
+                history[-1]["content"] = f"Sorry, I encountered an error while processing your request: {str(e)}"
+                yield history
+        except Exception as e:
+            logger.error(f"Bot streaming function error: {str(e)}")
+            if len(history) == 0 or history[-1].get("role") != "assistant":
+                history.append({"role": "assistant", "content": ""})
+            history[-1]["content"] = "I apologize, but I'm experiencing technical difficulties. Please try again in a moment."
+            yield history
+    @staticmethod
+    def bot(history: List[Dict], model_name: str = None) -> Generator[List[Dict], None, None]:
+        """
+        Main bot function with simulated streaming
+        Args:
+            history: Current Gradio chat history (for display only)
+            model_name: Model to use for the agent
+        Yields:
+            Updated history with bot response
+        """
+        try:
+            # Get agent instance with specified model
+            agent = UIHandlers.get_or_create_agent(model_name)
+            # Get input for agent from conversation manager
+            agent_input = conversation_manager.get_input_for_agent()
+            logger.info(f"Sending to agent ({current_model}): {type(agent_input)} - {conversation_manager.get_history_summary()}")
+            # Run agent safely with sync wrapper
+            result = AgentRunner.run_agent_safely_sync(agent, agent_input)
+            # Update conversation manager with the result
+            conversation_manager.update_from_result(result)
+            logger.info(f"Updated conversation manager. {conversation_manager.get_history_summary()}")
+            # Extract and format response for display
+            response = ResponseFormatter.extract_response_content(result)
+            # Stream the response with simulated typing
+            yield from ResponseFormatter.stream_response(response, history)
+        except Exception as e:
+            logger.error(f"Bot function error: {str(e)}")
+            error_response = "I apologize, but I'm experiencing technical difficulties. Please try again in a moment."
+            yield from ResponseFormatter.stream_response(error_response, history)
+    @staticmethod
+    def dynamic_bot(
+        history: List[Dict],
+        use_real_streaming: bool = True,
+        model_name: str = None
+    ) -> Generator[List[Dict], None, None]:
+        """
+        Dynamic bot function that can switch between streaming modes
+        Args:
+            history: Current Gradio chat history (for display only)
+            use_real_streaming: Whether to use real-time streaming from agent
+            model_name: Model to use for the agent
+        Yields:
+            Updated history with bot response
+        """
+        if use_real_streaming:
+            logger.info("Using real-time streaming mode")
+            yield from UIHandlers.bot_with_real_streaming(history, model_name)
+        else:
+            logger.info("Using simulated streaming mode")
+            yield from UIHandlers.bot(history, model_name)
+    @staticmethod
+    def clear_conversation() -> List[Dict]:
+        """
+        Clear the conversation history
+        Returns:
+            Empty chat history
+        """
+        global conversation_manager
+        conversation_manager.clear_history()
+        logger.info("Conversation history cleared")
+        return []

apps/gradio-app/src/fitness_gradio/ui/styles.py ADDED Viewed

	@@ -0,0 +1,162 @@

+"""
+CSS styles and theming for the fitness app UI.
+"""
+# Main CSS for the Gradio interface
+MAIN_CSS = """
+.gradio-container {
+    max-width: 1200px !important;
+}
+#chatbot {
+    height: 600px;
+}
+.model-info {
+    background: linear-gradient(135deg, rgba(55, 65, 81, 0.9), rgba(75, 85, 99, 0.7)) !important;
+    color: #e5e7eb !important;
+    padding: 16px !important;
+    border-radius: 12px !important;
+    border-left: 4px solid #10b981 !important;
+    margin: 12px 0 !important;
+    border: 1px solid rgba(75, 85, 99, 0.4) !important;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1) !important;
+    backdrop-filter: blur(10px) !important;
+}
+.model-info p {
+    color: #e5e7eb !important;
+    margin: 8px 0 !important;
+    line-height: 1.5 !important;
+}
+.model-info strong {
+    color: #f9fafb !important;
+    font-weight: 600 !important;
+}
+.model-info em {
+    color: #d1d5db !important;
+    font-style: italic;
+}
+.model-info code {
+    background-color: rgba(31, 41, 55, 0.8) !important;
+    color: #10b981 !important;
+    padding: 2px 6px !important;
+    border-radius: 4px !important;
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace !important;
+    font-size: 0.9em !important;
+}
+.model-dropdown {
+    font-weight: bold;
+}
+/* Ensure all text in model-info respects dark theme */
+.model-info * {
+    color: inherit !important;
+}
+/* Fix for any remaining white background issues */
+.model-info .prose {
+    color: #e5e7eb !important;
+}
+"""
+# Header markdown content
+HEADER_MARKDOWN = """
+# 🏋️‍♀️ Fitness AI Assistant
+Your personal fitness companion for workout plans, meal planning, and fitness guidance!
+💡 **Tips:**
+- Be specific about your fitness goals
+- Mention any physical limitations or preferences
+- Ask for modifications if needed
+- Choose your preferred AI model for different capabilities
+"""
+# Help content for the accordion
+HELP_CONTENT = """
+**What I can help you with:**
+- Create personalized workout plans
+- Design meal plans for your goals
+- Provide fitness guidance and tips
+- Suggest exercises for specific needs
+- Help modify existing plans
+**To get the best results:**
+- Tell me your fitness level (beginner, intermediate, advanced)
+- Mention your goals (weight loss, muscle gain, general fitness)
+- Include any equipment you have access to
+- Let me know about any injuries or limitations
+**AI Model Selection:**
+- **🔵 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
+- You can refer back to previous plans or discussions
+- Use the "Clear Conversation" button to start fresh
+- Each conversation maintains context across multiple exchanges
+**Streaming Options:**
+- **Real-time Streaming**: Responses appear as the AI generates them using `Runner.run_streamed()` (most engaging)
+- **Simulated Streaming**: Responses are generated fully, then displayed with typing effect (more reliable)
+- Toggle the streaming mode using the checkbox above
+- Real-time streaming shows tool calls, outputs, and message generation in real-time
+- **Note**: Anthropic models automatically fall back to non-streaming if validation errors occur
+"""
+# Model comparison guide content
+MODEL_COMPARISON_CONTENT = """
+## 🔵 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 | ★★★☆☆ | ★★★★★ | ★★☆☆☆ | 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 | ★★★★☆ | ★★★★★ | ★★☆☆☆ | **DEFAULT** - 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
+"""
+# Example prompts for the Examples component
+EXAMPLE_PROMPTS = [
+    "Create a beginner workout plan for me",
+    "I want to lose weight - help me with a fitness plan",
+    "Design a muscle building program for intermediate level",
+    "I need a meal plan for gaining muscle mass",
+    "What exercises should I do for better cardiovascular health?",
+    "Help me with a home workout routine with no equipment"
+]

fitness_agent/__init__.py CHANGED Viewed

	@@ -0,0 +1,7 @@

+"""
+Fitness Agent package - for Hugging Face Spaces deployment
+"""
+from .fitness_agent import FitnessAgent
+__all__ = ["FitnessAgent"]

fitness_agent/app.py CHANGED Viewed

@@ -1,1269 +1,68 @@
 import gradio as gr
-import time
-import asyncio
-import logging
-import re
-from typing import List, Dict, Any, Optional, Union, Generator
-from concurrent.futures import ThreadPoolExecutor
-from fitness_agent import FitnessAgent
-from agents import Agent, ItemHelpers, Runner, function_tool
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-# Check what streaming methods are available
-logger.info(f"Available Runner methods: {[method for method in dir(Runner) if not method.startswith('_')]}")
-class FitnessUIError(Exception):
-    """Custom exception for UI-related errors"""
-    pass
-class ConversationManager:
-    """Manages conversation history and state for the fitness agent"""
-    def __init__(self):
-        self.conversation_history: List[Dict[str, str]] = []
-        self.thread_id = "fitness_thread_001"  # Could be made dynamic per session
-    def add_user_message(self, content: str) -> None:
-        """Add a user message to the conversation history"""
-        self.conversation_history.append({"role": "user", "content": content})
-    def get_input_for_agent(self) -> Union[str, List[Dict[str, str]]]:
-        """Get the input format needed for the agent"""
-        if not self.conversation_history:
-            return "Hello"
-        elif len(self.conversation_history) == 1:
-            # First message - just send the content
-            return self.conversation_history[0]["content"]
-        else:
-            # Multiple messages - send the full history
-            return self.conversation_history
-    def update_from_result(self, result) -> None:
-        """Update conversation history from agent result"""
-        if hasattr(result, 'to_input_list'):
-            # Update our history with the complete conversation from the agent
-            self.conversation_history = result.to_input_list()
-        else:
-            # Fallback: manually add the assistant response
-            if hasattr(result, 'final_output'):
-                response_content = result.final_output
-            else:
-                response_content = str(result)
-            self.conversation_history.append({"role": "assistant", "content": str(response_content)})
-    def clear_history(self) -> None:
-        """Clear the conversation history"""
-        self.conversation_history = []
-    def get_history_summary(self) -> str:
-        """Get a summary of the conversation for debugging"""
-        return f"Conversation has {len(self.conversation_history)} messages"
-def get_or_create_agent(model_name: str = None) -> FitnessAgent:
-    """
-    Get the current agent or create a new one with the specified model
-    Args:
-        model_name: Name of the Anthropic model to use
-    Returns:
-        FitnessAgent instance
-    """
-    global current_agent, current_model
-    # Use default if no model specified
-    if model_name is None:
-        model_name = current_model
-    # Create new agent if model changed or no agent exists
-    if current_agent is None or current_model != model_name:
-        logger.info(f"Creating new agent with model: {model_name}")
-        current_agent = FitnessAgent(model_name)
-        current_model = model_name
-    return current_agent
-def change_model(new_model: str) -> str:
-    """
-    Change the current model and reset the agent
-    Args:
-        new_model: New model to use
-    Returns:
-        Status message
-    """
-    global current_agent, current_model
-    try:
-        # Validate model exists in our supported list
-        available_models = FitnessAgent.list_supported_models()
-        is_valid, validation_message = FitnessAgent.validate_model_name(new_model)
-        if not is_valid:
-            return f"❌ **Model Validation Failed**\n\n{validation_message}"
-        # 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:
-            # Get the full error details for debugging
-            error_str = str(model_error)
-            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 API account.
-💡 **This could mean:**
-- The model requires special access or higher tier subscription
-- The model has been deprecated
-- The model name is incorrect
-🎯 **Try these recommended models instead:**
-{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}`
-📝 **Error Type:** {error_type}
-📝 **Details:** {clean_error}
-🔧 **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
-        current_model = new_model
-        # Get model info for user feedback
-        model_info = FitnessAgent.get_model_info(new_model)
-        logger.info(f"Model changed to: {new_model}")
-        return f"""✅ **Model Successfully Changed!**
-🤖 **Current Model:** `{new_model}`
-💡 **Description:** {model_info}
-🔄 **Status:** Ready to chat with the new model. Your conversation history is preserved."""
-    except Exception as e:
-        logger.error(f"Error changing model: {str(e)}")
-        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
-    Args:
-        selected_model: Selected model from dropdown
-    Returns:
-        Formatted model information
-    """
-    # Ignore separator selections
-    separators = [
-        "--- Anthropic Models ---",
-        "--- OpenAI Models ---",
-        "--- Other Models ---",
-        "--- Legacy/Experimental ---"
-    ]
-    if selected_model in separators:
-        return f"""⚠️ **Please select a specific model**
-The separator "{selected_model}" is not a valid model choice.
-Please choose one of the actual model names from the dropdown."""
-    # Update the actual model
-    change_result = change_model(selected_model)
-    # If the change was successful, return success message, otherwise return the error
-    if "✅" in change_result:
-        try:
-            model_info = FitnessAgent.get_model_info(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}
-📊 **Status:** Model updated and ready to chat!"""
-        except Exception as e:
-            return f"""🤖 **Current Model:** `{selected_model}`
-❌ *Model information not available*
-📊 **Status:** Ready to chat!"""
-    else:
-        # Return the error message from change_model
-        return change_result
-def print_like_dislike(x: gr.LikeData) -> None:
-    """Log user feedback on messages"""
-    logger.info(f"User feedback - Index: {x.index}, Value: {x.value}, Liked: {x.liked}")
-# Global conversation manager instance
-conversation_manager = ConversationManager()
-# Global agent instance that can be updated with model changes
-current_agent = None
-current_model = "claude-3.5-haiku"  # Updated default model
-def add_message(history: List[Dict], message: Dict) -> tuple:
-    """
-    Add user message to chat history with proper validation
-    Args:
-        history: Current Gradio chat history (for display)
-        message: User message containing text and/or files
-    Returns:
-        Tuple of (updated_history, cleared_input)
-    """
-    try:
-        user_content_parts = []
-        # Handle file uploads
-        if message.get("files"):
-            for file_path in message["files"]:
-                if file_path:  # Validate file path exists
-                    file_content = f"[File uploaded: {file_path}]"
-                    user_content_parts.append(file_content)
-                    # Add to Gradio history for display
-                    history.append({
-                        "role": "user",
-                        "content": {"path": file_path}
-                    })
-        # Handle text input
-        if message.get("text") and message["text"].strip():
-            text_content = message["text"].strip()
-            user_content_parts.append(text_content)
-            # Add to Gradio history for display
-            history.append({
-                "role": "user",
-                "content": text_content
-            })
-        # Add to conversation manager (combine file and text content)
-        if user_content_parts:
-            combined_content = "\n".join(user_content_parts)
-            conversation_manager.add_user_message(combined_content)
-            logger.info(f"Added user message to conversation. {conversation_manager.get_history_summary()}")
-        return history, gr.MultimodalTextbox(value=None, interactive=False)
-    except Exception as e:
-        logger.error(f"Error adding message: {str(e)}")
-        # Add error message to history
-        history.append({
-            "role": "assistant",
-            "content": "Sorry, there was an error processing your message. Please try again."
-        })
-        return history, gr.MultimodalTextbox(value=None, interactive=False)
-async def run_agent_with_streaming(agent: FitnessAgent, agent_input: Union[str, List[Dict[str, str]]]):
-    """
-    Run the agent with streaming support using the correct Runner.run_streamed API
-    Args:
-        agent: The fitness agent instance
-        agent_input: Input for the agent (string for first message, list for conversation)
-    Yields:
-        Streaming response chunks from the agent with content and final result
-    """
-    try:
-        logger.info(f"Running agent with streaming. Input type: {type(agent_input)}")
-        # Use the correct streaming API
-        result = Runner.run_streamed(agent, agent_input)
-        accumulated_content = ""
-        final_result = None
-        has_content = False
-        try:
-            async for event in result.stream_events():
-                # Skip raw response events as suggested in the example
-                if event.type == "raw_response_event":
-                    continue
-                # Handle different event types
-                elif event.type == "agent_updated_stream_event":
-                    logger.debug(f"Agent updated: {event.new_agent.name}")
-                    continue
-                elif event.type == "run_item_stream_event":
-                    if event.item.type == "tool_call_item":
-                        logger.debug("Tool was called")
-                    elif event.item.type == "tool_call_output_item":
-                        logger.debug(f"Tool output: {event.item.output}")
-                    elif event.item.type == "message_output_item":
-                        # This is where the actual message content comes from
-                        try:
-                            message_content = ItemHelpers.text_message_output(event.item)
-                            if message_content:
-                                accumulated_content = message_content
-                                has_content = True
-                                # Yield a chunk-like object for streaming display
-                                yield {
-                                    'type': 'content_chunk',
-                                    'content': message_content,
-                                    'accumulated': accumulated_content
-                                }
-                        except Exception as item_error:
-                            logger.warning(f"Error extracting message content: {item_error}")
-                            # Continue processing other events
-                            continue
-        except Exception as streaming_error:
-            # Check if this is the specific Pydantic validation error for Anthropic models
-            error_str = str(streaming_error)
-            if "validation error for ResponseTextDeltaEvent" in error_str and "logprobs" in error_str:
-                logger.warning("Detected Anthropic model streaming validation error, falling back to non-streaming mode")
-                # Fall back to non-streaming execution
-                try:
-                    fallback_result = await Runner.run(agent, agent_input)
-                    final_result = fallback_result
-                    # Extract content from fallback result
-                    if hasattr(fallback_result, 'final_output'):
-                        accumulated_content = str(fallback_result.final_output)
-                    else:
-                        accumulated_content = str(fallback_result)
-                    has_content = True
-                    # Yield the content as if it was streamed
-                    yield {
-                        'type': 'content_chunk',
-                        'content': accumulated_content,
-                        'accumulated': accumulated_content
-                    }
-                except Exception as fallback_error:
-                    logger.error(f"Fallback execution also failed: {fallback_error}")
-                    raise streaming_error  # Re-raise original error
-            else:
-                # Re-raise if it's a different type of error
-                raise streaming_error
-        # Get the final result if we haven't already from fallback
-        if final_result is None:
-            try:
-                final_result = await result.get_final_result()
-            except Exception as final_error:
-                logger.warning(f"Error getting final result: {final_error}")
-                # Create a mock final result if we have content
-                if has_content:
-                    class MockResult:
-                        def __init__(self, content):
-                            self.final_output = content
-                        def to_input_list(self):
-                            return [{"role": "assistant", "content": self.final_output}]
-                    final_result = MockResult(accumulated_content)
-        # Yield the final result for conversation management
-        yield {
-            'type': 'final_result',
-            'result': final_result,
-            'content': accumulated_content
-        }
-    except Exception as e:
-        logger.error(f"Agent streaming error: {str(e)}")
-        # Return error as a final result-like object
-        class ErrorResult:
-            def __init__(self, error_message):
-                self.final_output = error_message
-            def to_input_list(self):
-                return []
-        yield {
-            'type': 'error',
-            'result': ErrorResult(f"Sorry, I encountered an error while processing your request: {str(e)}"),
-            'content': f"Sorry, I encountered an error while processing your request: {str(e)}"
-        }
-def run_agent_safely_sync(agent: FitnessAgent, agent_input: Union[str, List[Dict[str, str]]]) -> Any:
-    """
-    Synchronous wrapper for the agent execution - now using proper Runner.run method
-    Args:
-        agent: The fitness agent instance
-        agent_input: Input for the agent (string for first message, list for conversation)
-    Returns:
-        Final agent result
-    """
-    def _run_agent():
-        try:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                logger.info(f"Running agent sync with input type: {type(agent_input)}")
-                # Use the correct async method
-                async def run_async():
-                    return await Runner.run(agent, agent_input)
-                result = loop.run_until_complete(run_async())
-                return result
-            finally:
-                loop.close()
-        except Exception as e:
-            logger.error(f"Agent execution error: {str(e)}")
-            # Create a mock result object for error cases
-            class ErrorResult:
-                def __init__(self, error_message):
-                    self.final_output = error_message
-                def to_input_list(self):
-                    return []
-            return ErrorResult(f"Sorry, I encountered an error while processing your request: {str(e)}")
-    try:
-        with ThreadPoolExecutor(max_workers=1) as executor:
-            future = executor.submit(_run_agent)
-            # Add timeout to prevent hanging
-            return future.result(timeout=60)  # 60 second timeout
-    except Exception as e:
-        logger.error(f"Executor error: {str(e)}")
-        # Create a mock result object for error cases
-        class ErrorResult:
-            def __init__(self, error_message):
-                self.final_output = error_message
-            def to_input_list(self):
-                return []
-        return ErrorResult("Sorry, I'm having trouble processing your request right now. Please try again.")
-def parse_fitness_plan_from_string(plan_str: str) -> str:
-    """
-    Parse a fitness plan from its string representation
-    Args:
-        plan_str: String representation of a fitness plan object
-    Returns:
-        Formatted markdown string
-    """
-    try:
-        import re
-        # Extract name - handle both single and double quotes
-        name_match = re.search(r"name=['\"]([^'\"]*)['\"]", plan_str)
-        name = name_match.group(1) if name_match else "Fitness Plan"
-        # Extract training plan - handle both list format and simple string format
-        training_plan = ""
-        # Try list format first (with brackets and quotes)
-        training_match = re.search(r"training_plan=['\"](\[.*?\])['\"]", plan_str, re.DOTALL)
-        if training_match:
-            training_raw = training_match.group(1)
-            # Clean up the training plan format
-            training_items = re.findall(r'"([^"]*)"', training_raw)
-            training_plan = "\n".join(f"• {item.strip()}" for item in training_items if item.strip())
-        else:
-            # Try simple string format
-            training_match = re.search(r"training_plan=['\"]([^'\"]*)['\"]", plan_str)
-            if training_match:
-                training_raw = training_match.group(1)
-                # Split by common delimiters and format as bullet points
-                if ',' in training_raw:
-                    training_items = [item.strip() for item in training_raw.split(',')]
-                    training_plan = "\n".join(f"• {item}" for item in training_items if item)
-                else:
-                    training_plan = f"• {training_raw}"
-        # Extract meal plan - handle both list format and simple string format
-        meal_plan = ""
-        # Try list format first (with brackets and quotes)
-        meal_match = re.search(r"meal_plan=['\"](\[.*?\])['\"]", plan_str, re.DOTALL)
-        if meal_match:
-            meal_raw = meal_match.group(1)
-            # Clean up the meal plan format
-            meal_items = re.findall(r'"([^"]*)"', meal_raw)
-            meal_plan = "\n".join(f"• {item.strip()}" for item in meal_items if item.strip())
-        else:
-            # Try simple string format
-            meal_match = re.search(r"meal_plan=['\"]([^'\"]*)['\"]", plan_str)
-            if meal_match:
-                meal_raw = meal_match.group(1)
-                # Handle multi-line format with dashes or bullet points
-                if '\n-' in meal_raw or '\n•' in meal_raw:
-                    # Already has bullet points, just clean up
-                    meal_plan = meal_raw.strip()
-                elif ',' in meal_raw:
-                    # Split by commas and format as bullet points
-                    meal_items = [item.strip() for item in meal_raw.split(',')]
-                    meal_plan = "\n".join(f"• {item}" for item in meal_items if item)
-                else:
-                    meal_plan = f"• {meal_raw}"
-        # Format as markdown
-        formatted_plan = f"""# 🏋️ {name}
-## 💪 Training Plan
-{training_plan}
-## 🥗 Meal Plan
-{meal_plan}
----
-*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"""
-        return formatted_plan
-    except Exception as e:
-        logger.error(f"Error parsing fitness plan from string: {str(e)}")
-        # Fallback to basic formatting
-        return f"**Fitness Plan**\n\n{plan_str}"
-def format_fitness_plan(plan_obj: Any, style: str = "default") -> str:
-    """
-    Format a FitnessPlan object into a structured markdown string
-    Args:
-        plan_obj: The fitness plan object
-        style: Formatting style ("default", "minimal", "detailed")
-    Returns:
-        Formatted markdown string
-    """
-    try:
-        if not (hasattr(plan_obj, 'name') and
-                hasattr(plan_obj, 'training_plan') and
-                hasattr(plan_obj, 'meal_plan')):
-            return str(plan_obj)
-        if style == "minimal":
-            return f"""**{plan_obj.name}**
-**Training:** {plan_obj.training_plan}
-**Meals:** {plan_obj.meal_plan}"""
-        elif style == "detailed":
-            return f"""# 🏋️ {plan_obj.name}
-## 💪 Training Plan
-{plan_obj.training_plan}
-## 🥗 Meal Plan
-{plan_obj.meal_plan}
-## 📝 Additional Notes
-- Follow the plan consistently for best results
-- Adjust portions based on your energy levels
-- Stay hydrated throughout your workouts
-- Rest days are important for recovery
----
-*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"""
-        else:  # default
-            return f"""# 🏋️ {plan_obj.name}
-## 💪 Training Plan
-{plan_obj.training_plan}
-## 🥗 Meal Plan
-{plan_obj.meal_plan}
----
-*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"""
-    except Exception as e:
-        logger.error(f"Error formatting fitness plan: {str(e)}")
-        return str(plan_obj)
-def extract_response_content(result: Any) -> str:
-    """
-    Extract content from agent response with proper error handling
-    Args:
-        result: Agent response object
-    Returns:
-        Formatted response string
-    """
-    try:
-        # Handle different response types
-        if hasattr(result, 'final_output'):
-            response_data = result.final_output
-        else:
-            response_data = result
-        # Check if this is a structured FitnessPlan output
-        if (hasattr(response_data, 'name') and
-            hasattr(response_data, 'training_plan') and
-            hasattr(response_data, 'meal_plan')):
-            logger.info(f"Detected fitness plan object: {response_data.name}")
-            return format_fitness_plan(response_data)
-        # Check if the response_data is a string representation of a fitness plan
-        response_str = str(response_data)
-        if ("name=" in response_str and "training_plan=" in response_str and "meal_plan=" in response_str):
-            logger.info("Detected fitness plan in string format, attempting to parse")
-            return parse_fitness_plan_from_string(response_str)
-        elif isinstance(response_data, str):
-            return response_data
-        else:
-            return str(response_data)
-    except Exception as e:
-        logger.error(f"Error extracting response content: {str(e)}")
-        return "Sorry, I had trouble formatting my response. Please try asking again."
-def stream_response(response: str, history: List[Dict], chunk_size: int = 3) -> Generator[List[Dict], None, None]:
-    """
-    Stream response text with configurable chunk size for better UX
-    Args:
-        response: Response text to stream
-        history: Current chat history
-        chunk_size: Number of characters per chunk
-    Yields:
-        Updated history with streaming response
-    """
-    try:
-        history.append({"role": "assistant", "content": ""})
-        # Stream in chunks rather than character by character for better performance
-        for i in range(0, len(response), chunk_size):
-            chunk = response[i:i + chunk_size]
-            history[-1]["content"] += chunk
-            time.sleep(0.01)  # Faster streaming
-            yield history
-    except Exception as e:
-        logger.error(f"Error streaming response: {str(e)}")
-        # Fallback to showing full response
-        history[-1]["content"] = response
-        yield history
-def bot_with_real_streaming(history: List[Dict], model_name: str = None) -> Generator[List[Dict], None, None]:
-    """
-    Bot function with real-time streaming from the agent using Runner.run_streamed
-    Args:
-        history: Current Gradio chat history (for display only)
-        model_name: Model to use for the agent
-    Yields:
-        Updated history with real-time streaming response
-    """
-    try:
-        # Get agent instance with specified model
-        agent = get_or_create_agent(model_name)
-        # Get input for agent from conversation manager
-        agent_input = conversation_manager.get_input_for_agent()
-        logger.info(f"Sending to agent ({current_model}): {type(agent_input)} - {conversation_manager.get_history_summary()}")
-        # Add empty assistant message for streaming
-        history.append({"role": "assistant", "content": ""})
-        def _run_streaming():
-            """Synchronous wrapper for streaming execution with Anthropic fallback"""
-            try:
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                try:
-                    async def collect_streaming():
-                        """Collect results from the streaming agent with fallback handling"""
-                        content_chunks = []
-                        final_result = None
-                        streaming_worked = False
-                        try:
-                            async for chunk in run_agent_with_streaming(agent, agent_input):
-                                streaming_worked = True
-                                if chunk['type'] == 'content_chunk':
-                                    # Real-time content update
-                                    content_chunks.append(chunk['accumulated'])
-                                elif chunk['type'] == 'final_result':
-                                    # Final result for conversation management
-                                    final_result = chunk['result']
-                                    # Ensure we have the final content
-                                    if chunk['content'] and chunk['content'] not in content_chunks:
-                                        content_chunks.append(chunk['content'])
-                                elif chunk['type'] == 'error':
-                                    # Error handling
-                                    final_result = chunk['result']
-                                    content_chunks.append(chunk['content'])
-                        except Exception as stream_error:
-                            logger.warning(f"Streaming failed completely: {stream_error}")
-                            # Ultimate fallback - use the sync method
-                            if not streaming_worked:
-                                logger.info("Attempting sync fallback for Anthropic compatibility")
-                                try:
-                                    sync_result = await Runner.run(agent, agent_input)
-                                    final_result = sync_result
-                                    # Extract content
-                                    if hasattr(sync_result, 'final_output'):
-                                        content = str(sync_result.final_output)
-                                    else:
-                                        content = str(sync_result)
-                                    content_chunks.append(content)
-                                except Exception as sync_error:
-                                    logger.error(f"Both streaming and sync execution failed: {sync_error}")
-                                    content_chunks.append(f"Sorry, I encountered an error: {str(sync_error)}")
-                        # Update conversation manager with final result
-                        if final_result:
-                            conversation_manager.update_from_result(final_result)
-                            logger.info(f"Updated conversation manager. {conversation_manager.get_history_summary()}")
-                        # Process content chunks through extract_response_content for proper formatting
-                        processed_chunks = []
-                        for content in content_chunks:
-                            # Create a mock result object to use extract_response_content
-                            class MockContentResult:
-                                def __init__(self, content):
-                                    self.final_output = content
-                            mock_result = MockContentResult(content)
-                            formatted_content = extract_response_content(mock_result)
-                            processed_chunks.append(formatted_content)
-                        return processed_chunks
-                    return loop.run_until_complete(collect_streaming())
-                finally:
-                    loop.close()
-            except Exception as e:
-                logger.error(f"Streaming execution error: {str(e)}")
-                return [f"Sorry, I encountered an error: {str(e)}"]
-        # Execute streaming and yield updates
-        try:
-            with ThreadPoolExecutor(max_workers=1) as executor:
-                future = executor.submit(_run_streaming)
-                streaming_results = future.result(timeout=120)  # Increased timeout for fallback
-                # Stream the content updates to the UI
-                if streaming_results:
-                    for i, content in enumerate(streaming_results):
-                        history[-1]["content"] = content
-                        yield history
-                        # Add a small delay between updates for visual effect
-                        if i < len(streaming_results) - 1:  # Don't delay on the last update
-                            time.sleep(0.1)
-                else:
-                    # No content received
-                    history[-1]["content"] = "I apologize, but I didn't receive a response. Please try again."
-                    yield history
-        except Exception as e:
-            logger.error(f"Error in streaming execution: {str(e)}")
-            history[-1]["content"] = "Sorry, I had trouble processing your request."
-            yield history
-    except Exception as e:
-        logger.error(f"Bot streaming function error: {str(e)}")
-        if len(history) == 0 or history[-1].get("role") != "assistant":
-            history.append({"role": "assistant", "content": ""})
-        history[-1]["content"] = "I apologize, but I'm experiencing technical difficulties. Please try again in a moment."
-        yield history
-def bot(history: List[Dict], model_name: str = None) -> Generator[List[Dict], None, None]:
-    """
-    Main bot function with comprehensive error handling and improved UX using manual conversation management
-    Args:
-        history: Current Gradio chat history (for display only)
-        model_name: Model to use for the agent
-    Yields:
-        Updated history with bot response
-    """
-    try:
-        # Get agent instance with specified model
-        agent = get_or_create_agent(model_name)
-        # Get input for agent from conversation manager
-        agent_input = conversation_manager.get_input_for_agent()
-        logger.info(f"Sending to agent ({current_model}): {type(agent_input)} - {conversation_manager.get_history_summary()}")
-        # Run agent safely with sync wrapper
-        result = run_agent_safely_sync(agent, agent_input)
-        # Update conversation manager with the result
-        conversation_manager.update_from_result(result)
-        logger.info(f"Updated conversation manager. {conversation_manager.get_history_summary()}")
-        # Extract and format response for display
-        response = extract_response_content(result)
-        # Stream the response
-        yield from stream_response(response, history)
-    except Exception as e:
-        logger.error(f"Bot function error: {str(e)}")
-        error_response = "I apologize, but I'm experiencing technical difficulties. Please try again in a moment."
-        yield from stream_response(error_response, history)
-def dynamic_bot(history: List[Dict], use_real_streaming: bool = True, model_name: str = None) -> Generator[List[Dict], None, None]:
-    """
-    Dynamic bot function that can switch between streaming modes
-    Args:
-        history: Current Gradio chat history (for display only)
-        use_real_streaming: Whether to use real-time streaming from agent
-        model_name: Model to use for the agent
-    Yields:
-        Updated history with bot response
-    """
-    if use_real_streaming:
-        logger.info("Using real-time streaming mode")
-        yield from bot_with_real_streaming(history, model_name)
-    else:
-        logger.info("Using simulated streaming mode")
-        yield from bot(history, model_name)
-def clear_conversation() -> List[Dict]:
-    """
-    Clear the conversation history
-    Returns:
-        Empty chat history
-    """
-    global conversation_manager
-    conversation_manager.clear_history()
-    logger.info("Conversation history cleared")
-    return []
-# Gradio Interface
-with gr.Blocks(
-    theme=gr.themes.Soft(),
-    title="Fitness AI Assistant",
-    css="""
-    .gradio-container {
-        max-width: 1200px !important;
-    }
-    #chatbot {
-        height: 600px;
-    }
-    .model-info {
-        background: linear-gradient(135deg, rgba(55, 65, 81, 0.9), rgba(75, 85, 99, 0.7)) !important;
-        color: #e5e7eb !important;
-        padding: 16px !important;
-        border-radius: 12px !important;
-        border-left: 4px solid #10b981 !important;
-        margin: 12px 0 !important;
-        border: 1px solid rgba(75, 85, 99, 0.4) !important;
-        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1) !important;
-        backdrop-filter: blur(10px) !important;
-    }
-    .model-info p {
-        color: #e5e7eb !important;
-        margin: 8px 0 !important;
-        line-height: 1.5 !important;
-    }
-    .model-info strong {
-        color: #f9fafb !important;
-        font-weight: 600 !important;
-    }
-    .model-info em {
-        color: #d1d5db !important;
-        font-style: italic;
-    }
-    .model-info code {
-        background-color: rgba(31, 41, 55, 0.8) !important;
-        color: #10b981 !important;
-        padding: 2px 6px !important;
-        border-radius: 4px !important;
-        font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace !important;
-        font-size: 0.9em !important;
-    }
-    .model-dropdown {
-        font-weight: bold;
-    }
-    /* Ensure all text in model-info respects dark theme */
-    .model-info * {
-        color: inherit !important;
-    }
-    /* Fix for any remaining white background issues */
-    .model-info .prose {
-        color: #e5e7eb !important;
-    }
-    """
-) as demo:
-    gr.Markdown("""
-    # 🏋️‍♀️ Fitness AI Assistant
-    Your personal fitness companion for workout plans, meal planning, and fitness guidance!
-    💡 **Tips:**
-    - Be specific about your fitness goals
-    - Mention any physical limitations or preferences
-    - Ask for modifications if needed
-    - Choose your preferred AI model for different capabilities
-    """)
-    # Model selection section
-    with gr.Row():
-        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 model table data
-            table_data = FitnessAgent.get_models_table_data()
-            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`
-💡 **Description:** {FitnessAgent.get_model_info('claude-3.5-haiku')}
-📊 **Status:** Ready to chat!""",
-        visible=True,
-        elem_classes=["model-info"]
-    )
-    chatbot = gr.Chatbot(
-        elem_id="chatbot",
-        type="messages",
-        show_copy_button=True,
-        show_share_button=False,
-        avatar_images=None,
-        sanitize_html=True,
-        render_markdown=True
     )
-    chat_input = gr.MultimodalTextbox(
-        interactive=True,
-        file_count="multiple",
-        placeholder="Ask me about fitness, request a workout plan, or get meal planning advice...",
-        show_label=False,
-        sources=["microphone", "upload"],
-    )
-    # Add clear conversation button and streaming toggle
-    with gr.Row():
-        clear_btn = gr.Button("🗑️ Clear Conversation", variant="secondary", size="sm")
-        streaming_toggle = gr.Checkbox(
-            label="🚀 Enable Real-time Streaming",
-            value=True,
-            info="Stream responses in real-time as the agent generates them"
-        )
-    # Add example buttons for common requests
-    with gr.Row():
-        gr.Examples(
-            examples=[
-                "Create a beginner workout plan for me",
-                "I want to lose weight - help me with a fitness plan",
-                "Design a muscle building program for intermediate level",
-                "I need a meal plan for gaining muscle mass",
-                "What exercises should I do for better cardiovascular health?",
-                "Help me with a home workout routine with no equipment"
-            ],
-            inputs=chat_input,
-            label="💡 Try asking:"
-        )
-    # Add helpful information
-    with gr.Accordion("ℹ️ How to use this assistant", open=False):
-        gr.Markdown("""
-        **What I can help you with:**
-        - Create personalized workout plans
-        - Design meal plans for your goals
-        - Provide fitness guidance and tips
-        - Suggest exercises for specific needs
-        - Help modify existing plans
-        **To get the best results:**
-        - Tell me your fitness level (beginner, intermediate, advanced)
-        - Mention your goals (weight loss, muscle gain, general fitness)
-        - Include any equipment you have access to
-        - Let me know about any injuries or limitations
-        **AI Model Selection:**
-        - **🔵 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
-        - You can refer back to previous plans or discussions
-        - Use the "Clear Conversation" button to start fresh
-        - Each conversation maintains context across multiple exchanges
-        **Streaming Options:**
-        - **Real-time Streaming**: Responses appear as the AI generates them using `Runner.run_streamed()` (most engaging)
-        - **Simulated Streaming**: Responses are generated fully, then displayed with typing effect (more reliable)
-        - Toggle the streaming mode using the checkbox above
-        - Real-time streaming shows tool calls, outputs, and message generation in real-time
-        - **Note**: Anthropic models automatically fall back to non-streaming if validation errors occur
-        """)
-    # Add model comparison section
-    with gr.Accordion("🤖 Model Comparison Guide", open=False):
-        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(
-        add_message, [chatbot, chat_input], [chatbot, chat_input]
-    )
-    bot_msg = chat_msg.then(
-        dynamic_bot,
-        [chatbot, streaming_toggle, selected_model],
-        chatbot,
-        api_name="bot_response"
-    )
-    bot_msg.then(lambda: gr.MultimodalTextbox(interactive=True), None, [chat_input])
-    # 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
-    clear_btn.click(clear_conversation, None, chatbot)
-    chatbot.like(print_like_dislike, None, None, like_user_message=True)
 if __name__ == "__main__":
-    demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        show_error=True,
-        debug=False
     )

+"""
+Main Gradio app entry point for Hugging Face Spaces
+"""
+import os
+import sys
+from pathlib import Path
+# Add the necessary paths
+current_dir = Path(__file__).parent
+root_dir = current_dir.parent
+# Add shared library to path
+shared_path = root_dir / "shared" / "src"
+if str(shared_path) not in sys.path:
+    sys.path.insert(0, str(shared_path))
+# Add gradio app to path
+gradio_app_path = root_dir / "apps" / "gradio-app" / "src"
+if str(gradio_app_path) not in sys.path:
+    sys.path.insert(0, str(gradio_app_path))
+# Import required modules
 import gradio as gr
+try:
+    # Try to import the main Gradio UI
+    from fitness_gradio.ui import create_fitness_app
+    from fitness_core import setup_logging, Config, get_logger
+    # Configure logging
+    setup_logging(level=Config.LOG_LEVEL, log_file=Config.LOG_FILE)
+    logger = get_logger(__name__)
+    # Create the main app
+    app = create_fitness_app()
+except ImportError as e:
+    print(f"Warning: Could not import fitness modules: {e}")
+    print("Creating fallback Gradio interface...")
+    def respond(message, history):
+        """Fallback response function."""
+        return "I'm a fitness AI assistant. I'm currently loading my capabilities. Please try again in a moment, or ensure all dependencies are properly installed."
+    # Create fallback interface
+    app = gr.ChatInterface(
+        respond,
+        title="🏋️ Fitness AI Assistant",
+        description="Your personal AI-powered fitness and nutrition coach. I can help with workout plans, nutrition advice, and health guidance.",
+        examples=[
+            "Create a beginner workout plan for me",
+            "What should I eat for muscle gain?",
+            "How can I lose weight safely?",
+            "Design a 30-minute home workout"
+        ],
+        cache_examples=True,
+        theme=gr.themes.Soft()
     )
+# For Hugging Face Spaces
 if __name__ == "__main__":
+    # Launch the app
+    app.launch(
         server_name="0.0.0.0",
         server_port=7860,
+        share=False,
+        show_error=True
     )

fitness_agent/fitness_agent.py CHANGED Viewed

@@ -1,394 +1,87 @@
-from pydantic import BaseModel
-from agents import Agent, Runner
-from dotenv import load_dotenv
 import os
-from typing import Optional
-load_dotenv()
-class FitnessPlan(BaseModel):
-    name: str
-    training_plan: str
-    meal_plan: str
-class FitnessAgent(Agent):
-    """
-    A helpful assistant for general fitness guidance and handoffs to a plan-building agent.
-    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)
-    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 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": "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": "litellm/anthropic/claude-3-7-sonnet-20250219",
-        # Claude-3.5 models (widely available)
-        "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": "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 AI model (Anthropic or OpenAI).
-        Args:
-            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 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)
-        if not is_valid:
-            print(f"Warning: {validation_message}")
-            print(f"Falling back to default model: claude-3.5-haiku")
-            model_name = "claude-3.5-haiku"
-        # Resolve model name to full identifier
-        if model_name in self.SUPPORTED_MODELS:
-            full_model_name = self.SUPPORTED_MODELS[model_name]
-        else:
-            # Assume it's already a full model identifier
-            full_model_name = 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:
-            # 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.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=final_model,
-            output_type=FitnessPlan
-        )
-        super().__init__(
-            name="Fitness Assistant",
-            model=final_model,
-            instructions="""
-            You are a helpful assistant for fitness-related queries.
-            If the user wants to create a fitness plan, hand them off to the Fitness Plan Assistant.
-            """,
-            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."""
-        return cls.SUPPORTED_MODELS.copy()
-    @classmethod
-    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-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")
-    @classmethod
-    def get_recommended_models(cls) -> list:
-        """Get a list of recommended models that are most likely to be available."""
-        return [
-            # 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]:
-        """
-        Validate if a model name is in our supported list and provide helpful feedback.
-        Returns:
-            tuple: (is_valid, message)
-        """
-        if model_name in cls.SUPPORTED_MODELS:
-            full_name = cls.SUPPORTED_MODELS[model_name]
-            return True, f"Valid model: {model_name} -> {full_name}"
-        elif model_name in cls.SUPPORTED_MODELS.values():
-            return True, f"Valid full model identifier: {model_name}"
-        else:
-            recommended = ", ".join(cls.get_recommended_models())
-            return False, f"Model '{model_name}' not found. Recommended models: {recommended}"
-if __name__ == "__main__":
-    # Example usage with different models
-    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" + "="*60 + "\n")
-    # 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)")
-    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")
-    # 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 - Main application entry point for Hugging Face Spaces
+"""
+import sys
 import os
+from pathlib import Path
+# Add the necessary paths
+current_dir = Path(__file__).parent
+root_dir = current_dir.parent
+# Add shared library to path
+shared_path = root_dir / "shared" / "src"
+if str(shared_path) not in sys.path:
+    sys.path.insert(0, str(shared_path))
+# Add gradio app to path
+gradio_app_path = root_dir / "apps" / "gradio-app" / "src"
+if str(gradio_app_path) not in sys.path:
+    sys.path.insert(0, str(gradio_app_path))
+try:
+    from fitness_core import setup_logging, Config, get_logger
+    from fitness_core.agents.base import BaseAgent
+    from fitness_core.agents.models import AgentConfig
+    from fitness_core.services.agent_runner import AgentRunner
+    # Configure logging
+    setup_logging(level=Config.LOG_LEVEL, log_file=Config.LOG_FILE)
+    logger = get_logger(__name__)
+    class FitnessAgent(BaseAgent):
+        """Main Fitness Agent class for backwards compatibility."""
+        def __init__(self, config: AgentConfig = None):
+            """Initialize the fitness agent."""
+            if config is None:
+                # Create default config
+                config = AgentConfig(
+                    name="fitness_agent",
+                    description="AI-powered fitness and nutrition assistant",
+                    model_provider="openai",
+                    model_name="gpt-4",
+                    temperature=0.7
+                )
+            super().__init__(config)
+            self.runner = AgentRunner()
+        async def process_message(self, message: str, context: dict = None) -> str:
+            """Process a user message and return response."""
+            try:
+                response = await self.runner.run_agent(
+                    message=message,
+                    context=context or {}
+                )
+                return response
+            except Exception as e:
+                logger.error(f"Error processing message: {e}")
+                return f"I apologize, but I encountered an error: {str(e)}"
+        def get_capabilities(self) -> list:
+            """Get agent capabilities."""
+            return [
+                "Fitness program design",
+                "Nutrition advice",
+                "Workout planning",
+                "Health and wellness guidance"
+            ]
+except ImportError as e:
+    logger = None
+    print(f"Warning: Could not import fitness_core modules: {e}")
+    # Fallback FitnessAgent for basic functionality
+    class FitnessAgent:
+        """Fallback Fitness Agent when core modules aren't available."""
+        def __init__(self, config=None):
+            self.config = config
+        async def process_message(self, message: str, context: dict = None) -> str:
+            """Basic message processing fallback."""
+            return "I'm a fitness AI assistant. Please ensure all dependencies are properly installed."
+        def get_capabilities(self) -> list:
+            """Get basic capabilities."""
+            return ["Basic fitness assistance"]

requirements.txt CHANGED Viewed

@@ -1,4 +1,10 @@
-gradio==5.38.1
-openai-agents[litellm]==0.2.3
-python-dotenv==1.1.1
-reportlab==4.4.3

+# Core dependencies for Fitness AI Assistant
+gradio>=5.38.1
+openai-agents[litellm]>=0.2.3
+python-dotenv>=1.1.1
+pydantic>=2.0.0
+reportlab>=4.4.3
+# Additional dependencies that may be needed
+fastapi
+aiofiles

shared/README.md ADDED Viewed

	@@ -0,0 +1,20 @@

+# Fitness Core Library
+Shared business logic, AI agents, and utilities for the Fitness App ecosystem.
+## Components
+- **agents/**: AI agent implementations and model management
+- **models/**: Pydantic data models
+- **services/**: Core business logic and conversation management
+- **utils/**: Configuration, logging, and utility functions
+## Usage
+This library is designed to be imported by various frontend applications (Gradio, FastAPI, CLI, etc.)
+```python
+from fitness_core.agents import FitnessAgent
+from fitness_core.models import FitnessPlan
+from fitness_core.services import ConversationManager
+```

shared/requirements.txt ADDED Viewed

	@@ -0,0 +1,59 @@

+aiohappyeyeballs==2.6.1 ; python_version >= "3.12" and python_version < "4.0"
+aiohttp==3.12.14 ; python_version >= "3.12" and python_version < "4.0"
+aiosignal==1.4.0 ; python_version >= "3.12" and python_version < "4.0"
+annotated-types==0.7.0 ; python_version >= "3.12" and python_version < "4.0"
+anyio==4.9.0 ; python_version >= "3.12" and python_version < "4.0"
+attrs==25.3.0 ; python_version >= "3.12" and python_version < "4.0"
+certifi==2025.7.14 ; python_version >= "3.12" and python_version < "4.0"
+charset-normalizer==3.4.2 ; python_version >= "3.12" and python_version < "4.0"
+click==8.2.1 ; python_version >= "3.12" and python_version < "4.0"
+colorama==0.4.6 ; python_version >= "3.12" and python_version < "4.0"
+distro==1.9.0 ; python_version >= "3.12" and python_version < "4.0"
+filelock==3.18.0 ; python_version >= "3.12" and python_version < "4.0"
+frozenlist==1.7.0 ; python_version >= "3.12" and python_version < "4.0"
+fsspec==2025.7.0 ; python_version >= "3.12" and python_version < "4.0"
+griffe==1.8.0 ; python_version >= "3.12" and python_version < "4.0"
+h11==0.16.0 ; python_version >= "3.12" and python_version < "4.0"
+hf-xet==1.1.5 ; python_version >= "3.12" and python_version < "4.0" and (platform_machine == "x86_64" or platform_machine == "amd64" or platform_machine == "arm64" or platform_machine == "aarch64")
+httpcore==1.0.9 ; python_version >= "3.12" and python_version < "4.0"
+httpx-sse==0.4.1 ; python_version >= "3.12" and python_version < "4.0"
+httpx==0.28.1 ; python_version >= "3.12" and python_version < "4.0"
+huggingface-hub==0.34.1 ; python_version >= "3.12" and python_version < "4.0"
+idna==3.10 ; python_version >= "3.12" and python_version < "4.0"
+importlib-metadata==8.7.0 ; python_version >= "3.12" and python_version < "4.0"
+jinja2==3.1.6 ; python_version >= "3.12" and python_version < "4.0"
+jiter==0.10.0 ; python_version >= "3.12" and python_version < "4.0"
+jsonschema-specifications==2025.4.1 ; python_version >= "3.12" and python_version < "4.0"
+jsonschema==4.25.0 ; python_version >= "3.12" and python_version < "4.0"
+litellm==1.74.8 ; python_version >= "3.12" and python_version < "4.0"
+markupsafe==3.0.2 ; python_version >= "3.12" and python_version < "4.0"
+mcp==1.12.2 ; python_version >= "3.12" and python_version < "4.0"
+multidict==6.6.3 ; python_version >= "3.12" and python_version < "4.0"
+openai-agents[litellm]==0.2.3 ; python_version >= "3.12" and python_version < "4.0"
+openai==1.97.1 ; python_version >= "3.12" and python_version < "4.0"
+packaging==25.0 ; python_version >= "3.12" and python_version < "4.0"
+propcache==0.3.2 ; python_version >= "3.12" and python_version < "4.0"
+pydantic-core==2.33.2 ; python_version >= "3.12" and python_version < "4.0"
+pydantic-settings==2.10.1 ; python_version >= "3.12" and python_version < "4.0"
+pydantic==2.11.7 ; python_version >= "3.12" and python_version < "4.0"
+python-dotenv==1.1.1 ; python_version >= "3.12" and python_version < "4.0"
+python-multipart==0.0.20 ; python_version >= "3.12" and python_version < "4.0"
+pywin32==311 ; python_version >= "3.12" and python_version < "4.0" and sys_platform == "win32"
+pyyaml==6.0.2 ; python_version >= "3.12" and python_version < "4.0"
+referencing==0.36.2 ; python_version >= "3.12" and python_version < "4.0"
+regex==2024.11.6 ; python_version >= "3.12" and python_version < "4.0"
+requests==2.32.4 ; python_version >= "3.12" and python_version < "4.0"
+rpds-py==0.26.0 ; python_version >= "3.12" and python_version < "4.0"
+sniffio==1.3.1 ; python_version >= "3.12" and python_version < "4.0"
+sse-starlette==3.0.2 ; python_version >= "3.12" and python_version < "4.0"
+starlette==0.47.2 ; python_version >= "3.12" and python_version < "4.0"
+tiktoken==0.9.0 ; python_version >= "3.12" and python_version < "4.0"
+tokenizers==0.21.2 ; python_version >= "3.12" and python_version < "4.0"
+tqdm==4.67.1 ; python_version >= "3.12" and python_version < "4.0"
+types-requests==2.32.4.20250611 ; python_version >= "3.12" and python_version < "4.0"
+typing-extensions==4.14.1 ; python_version >= "3.12" and python_version < "4.0"
+typing-inspection==0.4.1 ; python_version >= "3.12" and python_version < "4.0"
+urllib3==2.5.0 ; python_version >= "3.12" and python_version < "4.0"
+uvicorn==0.35.0 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "emscripten"
+yarl==1.20.1 ; python_version >= "3.12" and python_version < "4.0"
+zipp==3.23.0 ; python_version >= "3.12" and python_version < "4.0"

shared/src/fitness_core/__init__.py ADDED Viewed

	@@ -0,0 +1,30 @@

+"""
+Fitness Core - Shared business logic and AI agents.
+This package contains the core functionality that can be shared across
+different user interfaces (Gradio, FastAPI, CLI, etc.).
+"""
+__version__ = "0.1.0"
+# Core exports
+from .agents import FitnessAgent, FitnessPlan, ModelProvider
+from .services import ConversationManager, AgentRunner, ResponseFormatter
+from .utils import Config, setup_logging, get_logger
+__all__ = [
+    # Agents
+    'FitnessAgent',
+    'FitnessPlan',
+    'ModelProvider',
+    # Services
+    'ConversationManager',
+    'AgentRunner',
+    'ResponseFormatter',
+    # Utils
+    'Config',
+    'setup_logging',
+    'get_logger'
+]

shared/src/fitness_core/agents/__init__.py ADDED Viewed

	@@ -0,0 +1,15 @@

+"""
+Agents module for the fitness core library.
+"""
+from .base import FitnessAgent
+from .models import FitnessPlan, AgentResponse, ConversationMessage, AgentConfig
+from .providers import ModelProvider
+__all__ = [
+    'FitnessAgent',
+    'FitnessPlan',
+    'AgentResponse',
+    'ConversationMessage',
+    'AgentConfig',
+    'ModelProvider'
+]

shared/src/fitness_core/agents/base.py ADDED Viewed

	@@ -0,0 +1,109 @@

+"""
+Main fitness agent implementation.
+"""
+from typing import Optional
+from agents import Agent
+from dotenv import load_dotenv
+from .models import FitnessPlan, AgentConfig
+from .providers import ModelProvider
+load_dotenv()
+class FitnessAgent(Agent):
+    """
+    A helpful assistant for general fitness guidance and handoffs to a plan-building agent.
+    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)
+    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.
+    """
+    def __init__(self, model_name: Optional[str] = None, config: Optional[AgentConfig] = None):
+        """
+        Initialize the Fitness Agent with configurable AI model (Anthropic or OpenAI).
+        Args:
+            model_name: Name of the AI model to use. Can be a key from SUPPORTED_MODELS
+                       or a full model identifier. Defaults to gpt-4o-mini if not specified.
+                       Can also be set via AI_MODEL, ANTHROPIC_MODEL, or OPENAI_MODEL environment variables.
+            config: Optional AgentConfig for additional configuration
+        """
+        # Resolve model name
+        resolved_model_name = ModelProvider.resolve_model_name(model_name)
+        final_model = ModelProvider.get_final_model_identifier(resolved_model_name)
+        # Store the model information for debugging
+        self.model_name = resolved_model_name
+        self.full_model_name = ModelProvider.SUPPORTED_MODELS.get(resolved_model_name, resolved_model_name)
+        self.final_model = final_model
+        self.provider = ModelProvider.get_provider(resolved_model_name, self.full_model_name)
+        self.config = config
+        # Create fitness plan agent
+        fitness_plan_agent = Agent(
+            name="Fitness Plan Assistant",
+            instructions="You are a helpful assistant for creating personalized fitness plans.",
+            model=final_model,
+            output_type=FitnessPlan
+        )
+        # Initialize parent Agent
+        super().__init__(
+            name="Fitness Assistant",
+            model=final_model,
+            instructions="""
+            You are a helpful assistant for fitness-related queries.
+            If the user wants to create a fitness plan, hand them off to the Fitness Plan Assistant.
+            """,
+            handoffs=[fitness_plan_agent]
+        )
+    @classmethod
+    def list_supported_models(cls) -> dict:
+        """Return a dictionary of supported model names and their full identifiers."""
+        return ModelProvider.SUPPORTED_MODELS.copy()
+    @classmethod
+    def get_model_info(cls, model_name: str) -> str:
+        """Get information about a specific model."""
+        return ModelProvider.get_model_info(model_name)
+    @classmethod
+    def get_recommended_models(cls) -> list:
+        """Get a list of recommended models that are most likely to be available."""
+        return ModelProvider.get_recommended_models()
+    @classmethod
+    def get_models_by_provider(cls) -> dict:
+        """Get models organized by provider."""
+        return ModelProvider.get_models_by_provider()
+    @classmethod
+    def get_models_table_data(cls) -> list:
+        """Get model data formatted for table display."""
+        return ModelProvider.get_models_table_data()
+    @classmethod
+    def validate_model_name(cls, model_name: str) -> tuple[bool, str]:
+        """
+        Validate if a model name is in our supported list and provide helpful feedback.
+        Returns:
+            tuple: (is_valid, message)
+        """
+        return ModelProvider.validate_model_name(model_name)

shared/src/fitness_core/agents/models.py ADDED Viewed

	@@ -0,0 +1,34 @@

+"""
+Pydantic models for the fitness agent.
+"""
+from pydantic import BaseModel
+from typing import Optional, List
+class FitnessPlan(BaseModel):
+    """Structured fitness plan model."""
+    name: str
+    training_plan: str
+    meal_plan: str
+class AgentResponse(BaseModel):
+    """Standard agent response format."""
+    content: str
+    plan: Optional[FitnessPlan] = None
+    metadata: Optional[dict] = None
+class ConversationMessage(BaseModel):
+    """Individual conversation message."""
+    role: str  # "user" or "assistant"
+    content: str
+    timestamp: Optional[str] = None
+class AgentConfig(BaseModel):
+    """Configuration for the fitness agent."""
+    model_name: str
+    temperature: Optional[float] = 0.7
+    max_tokens: Optional[int] = None
+    custom_instructions: Optional[str] = None

shared/src/fitness_core/agents/providers.py ADDED Viewed

	@@ -0,0 +1,298 @@

+"""
+AI model provider management and configuration.
+"""
+import os
+from typing import Dict, List, Tuple, Optional
+from .models import AgentConfig
+class ModelProvider:
+    """Manages AI model configurations and provider-specific logic."""
+    # 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": "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": "litellm/anthropic/claude-3-7-sonnet-20250219",
+        # Claude-3.5 models (widely available)
+        "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": "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
+    }
+    @classmethod
+    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-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")
+    @classmethod
+    def get_recommended_models(cls) -> List[str]:
+        """Get a list of recommended models that are most likely to be available."""
+        return [
+            # 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[str, Dict[str, str]]:
+        """Get models organized by provider."""
+        models = cls.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[List[str]]:
+        """Get model data formatted for table display."""
+        models = cls.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]:
+        """
+        Validate if a model name is in our supported list and provide helpful feedback.
+        Returns:
+            tuple: (is_valid, message)
+        """
+        if model_name in cls.SUPPORTED_MODELS:
+            full_name = cls.SUPPORTED_MODELS[model_name]
+            return True, f"Valid model: {model_name} -> {full_name}"
+        elif model_name in cls.SUPPORTED_MODELS.values():
+            return True, f"Valid full model identifier: {model_name}"
+        else:
+            recommended = ", ".join(cls.get_recommended_models())
+            return False, f"Model '{model_name}' not found. Recommended models: {recommended}"
+    @classmethod
+    def is_openai_model(cls, 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
+    @classmethod
+    def get_provider(cls, model_name: str, full_model_name: str) -> str:
+        """Determine the provider based on the model."""
+        if cls.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 resolve_model_name(cls, model_name: Optional[str] = None) -> str:
+        """
+        Resolve model name from various sources (env vars, default, etc.).
+        Args:
+            model_name: Explicit model name, if provided
+        Returns:
+            Resolved model name
+        """
+        if model_name is None:
+            # Check environment variables in priority order
+            model_name = (
+                os.getenv("AI_MODEL") or
+                os.getenv("ANTHROPIC_MODEL") or
+                os.getenv("OPENAI_MODEL") or
+                "gpt-4o-mini"  # Default fallback - reliable OpenAI model
+            )
+        # Validate the model name
+        is_valid, validation_message = cls.validate_model_name(model_name)
+        if not is_valid:
+            print(f"Warning: {validation_message}")
+            print(f"Falling back to default model: gpt-4o-mini")
+            model_name = "gpt-4o-mini"
+        return model_name
+    @classmethod
+    def get_final_model_identifier(cls, model_name: str) -> str:
+        """
+        Get the final model identifier to use with the agents library.
+        Args:
+            model_name: Model name (key or full identifier)
+        Returns:
+            Final model identifier for the agents library
+        """
+        # Resolve model name to full identifier
+        if model_name in cls.SUPPORTED_MODELS:
+            full_model_name = cls.SUPPORTED_MODELS[model_name]
+        else:
+            # Assume it's already a full model identifier
+            full_model_name = model_name
+        # Determine if this is an OpenAI model or needs LiteLLM prefix
+        if cls.is_openai_model(model_name, full_model_name):
+            # Use native OpenAI model (no prefix needed)
+            final_model = full_model_name
+        else:
+            # For Anthropic models, use the full model name as-is since it already has litellm/ prefix
+            final_model = full_model_name
+        return final_model

shared/src/fitness_core/services/__init__.py ADDED Viewed

	@@ -0,0 +1,24 @@

+"""
+Core services for the fitness core library.
+"""
+from .conversation import ConversationManager
+from .agent_runner import AgentRunner
+from .formatters import ResponseFormatter
+from .exceptions import (
+    FitnessAppError,
+    FitnessUIError,
+    AgentExecutionError,
+    ModelProviderError,
+    ConversationError
+)
+__all__ = [
+    'ConversationManager',
+    'AgentRunner',
+    'ResponseFormatter',
+    'FitnessAppError',
+    'FitnessUIError',
+    'AgentExecutionError',
+    'ModelProviderError',
+    'ConversationError'
+]

shared/src/fitness_core/services/agent_runner.py ADDED Viewed

	@@ -0,0 +1,246 @@

+"""
+Agent execution and streaming functionality.
+"""
+import asyncio
+import logging
+from typing import Union, List, Dict, Any, Generator, AsyncGenerator
+from concurrent.futures import ThreadPoolExecutor
+from agents import Runner
+from ..agents.base import FitnessAgent
+from .exceptions import AgentExecutionError
+logger = logging.getLogger(__name__)
+class AgentRunner:
+    """Handles agent execution with streaming and error management."""
+    @staticmethod
+    def run_agent_with_streaming_sync(
+        agent: FitnessAgent,
+        agent_input: Union[str, List[Dict[str, str]]]
+    ) -> Generator[Dict[str, Any], None, None]:
+        """
+        Run the agent with streaming support in a synchronous context (for Gradio)
+        Args:
+            agent: The fitness agent instance
+            agent_input: Input for the agent (string for first message, list for conversation)
+        Yields:
+            Streaming response chunks from the agent with content and final result
+        """
+        try:
+            logger.info(f"Running agent with streaming (sync). Input type: {type(agent_input)}")
+            # Handle event loop creation for worker threads
+            def _run_with_new_loop():
+                """Create a new event loop and run the agent"""
+                # Create a new event loop for this thread
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    # Now we can use Runner.run_sync which will use this loop
+                    return Runner.run_sync(agent, agent_input)
+                finally:
+                    # Clean up the loop
+                    loop.close()
+                    asyncio.set_event_loop(None)
+            try:
+                # Try direct call first (in case we're in main thread)
+                final_result = Runner.run_sync(agent, agent_input)
+            except RuntimeError as e:
+                if "no current event loop" in str(e).lower() or "anyio worker thread" in str(e).lower():
+                    # We're in a worker thread, create new event loop
+                    final_result = _run_with_new_loop()
+                else:
+                    raise
+            # Extract content and yield it
+            content = AgentRunner._extract_content_from_result(final_result)
+            # Simulate streaming by yielding the result
+            yield {
+                'type': 'final_result',
+                'result': final_result,
+                'content': content
+            }
+        except Exception as e:
+            logger.error(f"Agent execution error: {str(e)}")
+            # Return error as a final result-like object
+            class ErrorResult:
+                def __init__(self, content):
+                    self.final_output = content
+                def to_input_list(self):
+                    return [{"role": "assistant", "content": self.final_output}]
+            yield {
+                'type': 'error',
+                'result': ErrorResult(f"Sorry, I encountered an error while processing your request: {str(e)}"),
+                'content': f"Sorry, I encountered an error while processing your request: {str(e)}"
+            }
+    @staticmethod
+    async def run_agent_with_streaming(
+        agent: FitnessAgent,
+        agent_input: Union[str, List[Dict[str, str]]]
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Run the agent with streaming support using the correct Runner.run_streamed API
+        Args:
+            agent: The fitness agent instance
+            agent_input: Input for the agent (string for first message, list for conversation)
+        Yields:
+            Streaming response chunks from the agent with content and final result
+        """
+        try:
+            logger.info(f"Running agent with streaming. Input type: {type(agent_input)}")
+            # Use the correct streaming API
+            result = Runner.run_streamed(agent, agent_input)
+            accumulated_content = ""
+            final_result = None
+            has_content = False
+            try:
+                async for chunk in result:
+                    if hasattr(chunk, 'content') and chunk.content:
+                        accumulated_content += chunk.content
+                        has_content = True
+                        yield {
+                            'type': 'chunk',
+                            'content': chunk.content,
+                            'accumulated': accumulated_content
+                        }
+                    elif hasattr(chunk, 'final_output'):
+                        final_result = chunk
+                        break
+                # If we didn't get content through streaming, try direct execution
+                if not has_content:
+                    logger.info("No streaming content received, falling back to direct execution")
+                    final_result = Runner.run_sync(agent, agent_input)
+                    accumulated_content = AgentRunner._extract_content_from_result(final_result)
+            except Exception as streaming_error:
+                logger.warning(f"Streaming failed: {streaming_error}, falling back to sync execution")
+                final_result = Runner.run_sync(agent, agent_input)
+                accumulated_content = AgentRunner._extract_content_from_result(final_result)
+            # Get the final result if we haven't already from fallback
+            if final_result is None:
+                final_result = Runner.run_sync(agent, agent_input)
+            # Yield the final result for conversation management
+            yield {
+                'type': 'final_result',
+                'result': final_result,
+                'content': accumulated_content
+            }
+        except Exception as e:
+            logger.error(f"Agent streaming error: {str(e)}")
+            # Return error as a final result-like object
+            class ErrorResult:
+                def __init__(self, content):
+                    self.final_output = content
+                def to_input_list(self):
+                    return [{"role": "assistant", "content": self.final_output}]
+            yield {
+                'type': 'error',
+                'result': ErrorResult(f"Sorry, I encountered an error while processing your request: {str(e)}"),
+                'content': f"Sorry, I encountered an error while processing your request: {str(e)}"
+            }
+    @staticmethod
+    def run_agent_safely_sync(
+        agent: FitnessAgent,
+        agent_input: Union[str, List[Dict[str, str]]]
+    ) -> Any:
+        """
+        Synchronous wrapper for the agent execution - with event loop handling
+        Args:
+            agent: The fitness agent instance
+            agent_input: Input for the agent (string for first message, list for conversation)
+        Returns:
+            Final agent result
+        """
+        try:
+            # Handle event loop creation for worker threads
+            def _run_with_new_loop():
+                """Create a new event loop and run the agent"""
+                # Create a new event loop for this thread
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    # Now we can use Runner.run_sync which will use this loop
+                    return Runner.run_sync(agent, agent_input)
+                finally:
+                    # Clean up the loop
+                    loop.close()
+                    asyncio.set_event_loop(None)
+            try:
+                # Try direct call first (in case we're in main thread)
+                return Runner.run_sync(agent, agent_input)
+            except RuntimeError as e:
+                if "no current event loop" in str(e).lower() or "anyio worker thread" in str(e).lower():
+                    # We're in a worker thread, create new event loop
+                    return _run_with_new_loop()
+                else:
+                    raise
+        except Exception as e:
+            logger.error(f"Agent execution error: {str(e)}")
+            # Create a mock result object for error cases
+            class ErrorResult:
+                def __init__(self, error_message):
+                    self.final_output = error_message
+                def to_input_list(self):
+                    return [{"role": "assistant", "content": self.final_output}]
+            return ErrorResult(f"Sorry, I encountered an error while processing your request: {str(e)}")
+    @staticmethod
+    def _extract_content_from_result(result: Any) -> str:
+        """
+        Extract content from agent response with proper error handling
+        Args:
+            result: Agent response object
+        Returns:
+            Formatted response string
+        """
+        try:
+            if hasattr(result, 'final_output'):
+                content = result.final_output
+                # Check if this looks like a fitness plan
+                if hasattr(content, 'name') and hasattr(content, 'training_plan'):
+                    from .formatters import ResponseFormatter
+                    return ResponseFormatter.format_fitness_plan(content)
+                else:
+                    return str(content)
+            elif hasattr(result, 'content'):
+                return str(result.content)
+            elif isinstance(result, str):
+                return result
+            else:
+                return str(result)
+        except Exception as e:
+            logger.error(f"Error extracting content from result: {str(e)}")
+            return f"Sorry, I encountered an error while formatting the response: {str(e)}"

shared/src/fitness_core/services/conversation.py ADDED Viewed

	@@ -0,0 +1,93 @@

+"""
+Conversation management for the fitness agent.
+"""
+from typing import List, Dict, Union, Any
+from ..agents.models import ConversationMessage
+from .exceptions import ConversationError
+class ConversationManager:
+    """Manages conversation history and state for the fitness agent"""
+    def __init__(self):
+        self.conversation_history: List[Dict[str, str]] = []
+        self.thread_id = "fitness_thread_001"  # Could be made dynamic per session
+    def add_user_message(self, content: str) -> None:
+        """Add a user message to the conversation history"""
+        if not content or not content.strip():
+            raise ConversationError("Cannot add empty message to conversation")
+        self.conversation_history.append({"role": "user", "content": content.strip()})
+    def add_assistant_message(self, content: str) -> None:
+        """Add an assistant message to the conversation history"""
+        if not content or not content.strip():
+            raise ConversationError("Cannot add empty assistant message to conversation")
+        self.conversation_history.append({"role": "assistant", "content": content.strip()})
+    def get_input_for_agent(self) -> Union[str, List[Dict[str, str]]]:
+        """Get the input format needed for the agent"""
+        if not self.conversation_history:
+            return "Hello"
+        elif len(self.conversation_history) == 1:
+            # First message - just send the content
+            return self.conversation_history[0]["content"]
+        else:
+            # Multiple messages - send the full history
+            return self.conversation_history
+    def update_from_result(self, result: Any) -> None:
+        """Update conversation history from agent result"""
+        try:
+            if hasattr(result, 'to_input_list'):
+                # Update our history with the complete conversation from the agent
+                self.conversation_history = result.to_input_list()
+            else:
+                # Extract content and add as assistant message
+                content = self._extract_content_from_result(result)
+                if content:
+                    self.add_assistant_message(content)
+        except Exception as e:
+            raise ConversationError(f"Failed to update conversation from result: {str(e)}")
+    def _extract_content_from_result(self, result: Any) -> str:
+        """Extract content from various result formats"""
+        if hasattr(result, 'final_output'):
+            return str(result.final_output)
+        elif hasattr(result, 'content'):
+            return str(result.content)
+        elif isinstance(result, str):
+            return result
+        else:
+            return str(result)
+    def clear_history(self) -> None:
+        """Clear the conversation history"""
+        self.conversation_history = []
+    def get_history_summary(self) -> str:
+        """Get a summary of the conversation for debugging"""
+        return f"Conversation has {len(self.conversation_history)} messages"
+    def get_last_user_message(self) -> str:
+        """Get the last user message"""
+        for message in reversed(self.conversation_history):
+            if message["role"] == "user":
+                return message["content"]
+        return ""
+    def get_last_assistant_message(self) -> str:
+        """Get the last assistant message"""
+        for message in reversed(self.conversation_history):
+            if message["role"] == "assistant":
+                return message["content"]
+        return ""
+    def get_conversation_as_messages(self) -> List[ConversationMessage]:
+        """Get conversation as structured ConversationMessage objects"""
+        return [
+            ConversationMessage(role=msg["role"], content=msg["content"])
+            for msg in self.conversation_history
+        ]

shared/src/fitness_core/services/exceptions.py ADDED Viewed

	@@ -0,0 +1,28 @@

+"""
+Custom exceptions for the fitness app.
+"""
+class FitnessAppError(Exception):
+    """Base exception for fitness app errors."""
+    pass
+class FitnessUIError(FitnessAppError):
+    """Custom exception for UI-related errors."""
+    pass
+class AgentExecutionError(FitnessAppError):
+    """Exception for agent execution errors."""
+    pass
+class ModelProviderError(FitnessAppError):
+    """Exception for model provider errors."""
+    pass
+class ConversationError(FitnessAppError):
+    """Exception for conversation management errors."""
+    pass

shared/src/fitness_core/services/formatters.py ADDED Viewed

	@@ -0,0 +1,206 @@

+"""
+Response formatting utilities for the fitness app.
+"""
+import re
+import logging
+from typing import Any, Generator, List, Dict
+logger = logging.getLogger(__name__)
+class ResponseFormatter:
+    """Handles formatting of various response types."""
+    @staticmethod
+    def format_fitness_plan(plan_obj: Any, style: str = "default") -> str:
+        """
+        Format a FitnessPlan object into a structured markdown string
+        Args:
+            plan_obj: The fitness plan object
+            style: Formatting style ("default", "minimal", "detailed")
+        Returns:
+            Formatted markdown string
+        """
+        try:
+            if not (hasattr(plan_obj, 'name') and
+                    hasattr(plan_obj, 'training_plan') and
+                    hasattr(plan_obj, 'meal_plan')):
+                # Try to parse as string if it's not a proper object
+                if isinstance(plan_obj, str):
+                    return ResponseFormatter.parse_fitness_plan_from_string(plan_obj)
+                else:
+                    return f"**Fitness Plan**\n\n{str(plan_obj)}"
+            if style == "minimal":
+                return f"""**{plan_obj.name}**
+**Training:** {plan_obj.training_plan}
+**Meals:** {plan_obj.meal_plan}"""
+            elif style == "detailed":
+                return f"""# 🏋️ {plan_obj.name}
+## 💪 Training Plan
+{plan_obj.training_plan}
+## 🥗 Meal Plan
+{plan_obj.meal_plan}
+## 📊 Additional Information
+- Plan created with AI assistance
+- Customize as needed for your preferences
+- Consult healthcare providers for medical advice
+---
+*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"""
+            else:  # default style
+                return f"""# 🏋️ {plan_obj.name}
+## 💪 Training Plan
+{plan_obj.training_plan}
+## 🥗 Meal Plan
+{plan_obj.meal_plan}
+---
+*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"""
+        except Exception as e:
+            logger.error(f"Error formatting fitness plan: {str(e)}")
+            return f"**Fitness Plan**\n\nI created a fitness plan for you, but encountered an error while formatting it. Here's the raw content:\n\n{str(plan_obj)}"
+    @staticmethod
+    def parse_fitness_plan_from_string(plan_str: str) -> str:
+        """
+        Parse a fitness plan from its string representation
+        Args:
+            plan_str: String representation of a fitness plan object
+        Returns:
+            Formatted markdown string
+        """
+        try:
+            # Extract name - handle both single and double quotes
+            name_match = re.search(r"name=['\"]([^'\"]*)['\"]", plan_str)
+            name = name_match.group(1) if name_match else "Fitness Plan"
+            # Extract training plan - handle both list format and simple string format
+            training_plan = ""
+            # Try list format first (with brackets and quotes)
+            training_match = re.search(r"training_plan=['\"](\[.*?\])['\"]", plan_str, re.DOTALL)
+            if training_match:
+                training_raw = training_match.group(1)
+                # Clean up the list format
+                training_plan = training_raw.replace('[', '').replace(']', '').replace("'", "").replace('"', '')
+                training_plan = training_plan.replace(',', '\n').strip()
+            else:
+                # Try simple string format
+                training_match = re.search(r"training_plan=['\"]([^'\"]*)['\"]", plan_str, re.DOTALL)
+                if training_match:
+                    training_plan = training_match.group(1)
+            # Extract meal plan - handle both list format and simple string format
+            meal_plan = ""
+            # Try list format first (with brackets and quotes)
+            meal_match = re.search(r"meal_plan=['\"](\[.*?\])['\"]", plan_str, re.DOTALL)
+            if meal_match:
+                meal_raw = meal_match.group(1)
+                # Clean up the list format
+                meal_plan = meal_raw.replace('[', '').replace(']', '').replace("'", "").replace('"', '')
+                meal_plan = meal_plan.replace(',', '\n').strip()
+            else:
+                # Try simple string format
+                meal_match = re.search(r"meal_plan=['\"]([^'\"]*)['\"]", plan_str, re.DOTALL)
+                if meal_match:
+                    meal_plan = meal_match.group(1)
+            # Format as markdown
+            formatted_plan = f"""# 🏋️ {name}
+## 💪 Training Plan
+{training_plan}
+## 🥗 Meal Plan
+{meal_plan}
+---
+*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"""
+            return formatted_plan
+        except Exception as e:
+            logger.error(f"Error parsing fitness plan from string: {str(e)}")
+            # Fallback to basic formatting
+            return f"**Fitness Plan**\n\n{plan_str}"
+    @staticmethod
+    def extract_response_content(result: Any) -> str:
+        """
+        Extract content from agent response with proper error handling
+        Args:
+            result: Agent response object
+        Returns:
+            Formatted response string
+        """
+        try:
+            if hasattr(result, 'final_output'):
+                content = result.final_output
+                # Check if this looks like a fitness plan
+                if hasattr(content, 'name') and hasattr(content, 'training_plan'):
+                    return ResponseFormatter.format_fitness_plan(content)
+                elif isinstance(content, str) and ('training_plan=' in content or 'meal_plan=' in content):
+                    return ResponseFormatter.parse_fitness_plan_from_string(content)
+                else:
+                    return str(content)
+            elif hasattr(result, 'content'):
+                return str(result.content)
+            elif isinstance(result, str):
+                return result
+            else:
+                return str(result)
+        except Exception as e:
+            logger.error(f"Error extracting content from result: {str(e)}")
+            return f"Sorry, I encountered an error while formatting the response: {str(e)}"
+    @staticmethod
+    def stream_response(
+        response: str,
+        history: List[Dict],
+        chunk_size: int = 3
+    ) -> Generator[List[Dict], None, None]:
+        """
+        Stream response text with configurable chunk size for better UX
+        Args:
+            response: Response text to stream
+            history: Current chat history
+            chunk_size: Number of characters per chunk
+        Yields:
+            Updated history with streaming response
+        """
+        try:
+            # Add empty assistant message to history
+            history = history + [{"role": "assistant", "content": ""}]
+            # Stream the response character by character or in chunks
+            for i in range(0, len(response), chunk_size):
+                chunk = response[i:i + chunk_size]
+                history[-1]["content"] += chunk
+                yield history
+        except Exception as e:
+            logger.error(f"Error streaming response: {str(e)}")
+            # Fallback to complete response
+            history = history + [{"role": "assistant", "content": response}]
+            yield history

shared/src/fitness_core/utils/__init__.py ADDED Viewed

	@@ -0,0 +1,11 @@

+"""
+Utilities for the fitness core library.
+"""
+from .config import Config
+from .logging import setup_logging, get_logger
+__all__ = [
+    'Config',
+    'setup_logging',
+    'get_logger'
+]

shared/src/fitness_core/utils/config.py ADDED Viewed

	@@ -0,0 +1,79 @@

+"""
+Configuration management for the fitness app.
+"""
+import os
+from typing import Optional, Dict, Any
+from dotenv import load_dotenv
+# Load environment variables
+load_dotenv()
+class Config:
+    """Application configuration management."""
+    # Server configuration
+    SERVER_NAME: str = os.getenv("SERVER_NAME", "0.0.0.0")
+    SERVER_PORT: int = int(os.getenv("SERVER_PORT", "7860"))
+    DEBUG: bool = os.getenv("DEBUG", "false").lower() == "true"
+    # AI Model configuration
+    DEFAULT_MODEL: str = os.getenv("AI_MODEL", os.getenv("OPENAI_MODEL", "gpt-4o-mini"))
+    ANTHROPIC_API_KEY: Optional[str] = os.getenv("ANTHROPIC_API_KEY")
+    OPENAI_API_KEY: Optional[str] = os.getenv("OPENAI_API_KEY")
+    # Logging configuration
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    LOG_FILE: Optional[str] = os.getenv("LOG_FILE")
+    # UI configuration
+    MAX_CHAT_HISTORY: int = int(os.getenv("MAX_CHAT_HISTORY", "50"))
+    STREAMING_CHUNK_SIZE: int = int(os.getenv("STREAMING_CHUNK_SIZE", "3"))
+    @classmethod
+    def get_gradio_config(cls) -> Dict[str, Any]:
+        """Get configuration for Gradio app launch."""
+        return {
+            "server_name": cls.SERVER_NAME,
+            "server_port": cls.SERVER_PORT,
+            "show_error": True,
+            "debug": cls.DEBUG
+        }
+    @classmethod
+    def has_anthropic_key(cls) -> bool:
+        """Check if Anthropic API key is configured."""
+        return cls.ANTHROPIC_API_KEY is not None and len(cls.ANTHROPIC_API_KEY.strip()) > 0
+    @classmethod
+    def has_openai_key(cls) -> bool:
+        """Check if OpenAI API key is configured."""
+        return cls.OPENAI_API_KEY is not None and len(cls.OPENAI_API_KEY.strip()) > 0
+    @classmethod
+    def validate_config(cls) -> Dict[str, Any]:
+        """Validate configuration and return status."""
+        status = {
+            "valid": True,
+            "warnings": [],
+            "errors": []
+        }
+        # Check API keys
+        if not cls.has_anthropic_key() and not cls.has_openai_key():
+            status["errors"].append(
+                "No API keys configured. Please set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable."
+            )
+            status["valid"] = False
+        if not cls.has_anthropic_key():
+            status["warnings"].append("ANTHROPIC_API_KEY not set - Claude models will not work")
+        if not cls.has_openai_key():
+            status["warnings"].append("OPENAI_API_KEY not set - OpenAI models will not work")
+        # Check port availability (basic check)
+        if not (1024 <= cls.SERVER_PORT <= 65535):
+            status["warnings"].append(f"Server port {cls.SERVER_PORT} may not be valid")
+        return status

shared/src/fitness_core/utils/logging.py ADDED Viewed

	@@ -0,0 +1,63 @@

+"""
+Logging configuration for the fitness app.
+"""
+import logging
+import sys
+from typing import Optional
+def setup_logging(level: str = "INFO", log_file: Optional[str] = None) -> None:
+    """
+    Configure logging for the fitness app.
+    Args:
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Optional file path to write logs to
+    """
+    # Convert string level to logging constant
+    numeric_level = getattr(logging, level.upper(), logging.INFO)
+    # Create formatter
+    formatter = logging.Formatter(
+        fmt='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(numeric_level)
+    # Clear existing handlers
+    root_logger.handlers.clear()
+    # Add console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(numeric_level)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+    # Add file handler if specified
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(numeric_level)
+        file_handler.setFormatter(formatter)
+        root_logger.addHandler(file_handler)
+    # Set specific logger levels
+    logging.getLogger("fitness_app").setLevel(numeric_level)
+    logging.getLogger("agents").setLevel(logging.WARNING)  # Reduce noise from agents library
+    logging.getLogger("httpx").setLevel(logging.WARNING)    # Reduce HTTP noise
+    logging.getLogger("gradio").setLevel(logging.INFO)      # Keep Gradio info
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance for the given name.
+    Args:
+        name: Logger name (usually __name__)
+    Returns:
+        Configured logger instance
+    """
+    return logging.getLogger(name)