🤖 Auto-deploy from GitHub (push) - f6b8a83 - 2025-08-05 04:25:29 UTC

.env.example

@@ -14,10 +14,10 @@ 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 gpt-4o-mini if not set)
+# Optional: Set default model (will use gpt-4o if not set)
+# AI_MODEL=gpt-4o
 # AI_MODEL=gpt-4o-mini
 # AI_MODEL=claude-3.5-sonnet
-# AI_MODEL=gpt-4o
 
 # Alternative environment variable names (for compatibility)
 # ANTHROPIC_MODEL=claude-3.5-haiku

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

@@ -2,9 +2,10 @@
 UI components for the fitness app.
 """
 import gradio as gr
-from typing import List
+from typing import List, Any
 
 from fitness_core.agents import FitnessAgent
+from fitness_core.agents.providers import ModelProvider
 from .styles import (
     HEADER_MARKDOWN, 
     HELP_CONTENT, 
@@ -127,10 +128,13 @@ class UIComponents:
             # Add OpenAI models last
             dropdown_choices.extend(openai_models)
             
+            # Get the configured default model from environment/config
+            default_model = ModelProvider.resolve_model_name()
+            
             # Main model selection dropdown (full width)
             model_dropdown = gr.Dropdown(
                 choices=dropdown_choices,
-                value="claude-3.5-haiku",
+                value=default_model,
                 label="Select AI Model",
                 info="Choose your preferred AI model for fitness guidance",
                 elem_classes=["model-dropdown"]
@@ -138,7 +142,7 @@ class UIComponents:
             
             # Hidden component to manage selection (for compatibility)
             selected_model = gr.Textbox(
-                value="claude-3.5-haiku",
+                value=default_model,
                 visible=False,
                 label="Selected Model"
             )
@@ -318,3 +322,508 @@ class UIComponents:
             )
         
         return plan_display, view_plan_btn, clear_plan_btn
+
+    @staticmethod
+    def format_structured_fitness_plan(plan_obj: Any) -> str:
+        """
+        Format a structured fitness plan object into a nicely formatted markdown string.
+        
+        Args:
+            plan_obj: The fitness plan object with structured attributes
+            
+        Returns:
+            Formatted markdown string
+        """
+        try:
+            # Handle structured FitnessPlan object
+            if hasattr(plan_obj, 'name') and hasattr(plan_obj, 'training_plan'):
+                return UIComponents._format_fitness_plan_object(plan_obj)
+            
+            # Handle string representation of structured object
+            elif isinstance(plan_obj, str) and 'training_plan_splits=' in plan_obj:
+                return UIComponents._format_structured_plan_string(plan_obj)
+            
+            # Fallback to basic formatting
+            else:
+                return f"**Fitness Plan**\n\n{str(plan_obj)}"
+                
+        except Exception as e:
+            return f"**Error Formatting Plan**\n\nSorry, there was an error formatting your fitness plan: {str(e)}"
+
+    @staticmethod
+    def _format_fitness_plan_object(plan_obj: Any) -> str:
+        """Format a structured FitnessPlan object."""
+        try:
+            # Extract basic plan info
+            plan_name = getattr(plan_obj, 'name', 'Fitness Plan')
+            plan_goal = getattr(plan_obj, 'goal', '')
+            plan_description = getattr(plan_obj, 'description', '')
+            meal_plan = getattr(plan_obj, 'meal_plan', '')
+            
+            # Format header
+            formatted = f"# 🏋️ {plan_name}\n\n"
+            
+            if plan_goal:
+                formatted += f"**🎯 Goal:** {plan_goal}\n\n"
+            
+            if plan_description:
+                formatted += f"**📋 Overview:** {plan_description}\n\n"
+            
+            # Format training plan
+            training_plan = getattr(plan_obj, 'training_plan', None)
+            if training_plan:
+                formatted += "## 💪 Training Plan\n\n"
+                formatted += UIComponents._format_training_plan(training_plan)
+            
+            # Format meal plan
+            if meal_plan:
+                formatted += "\n## 🥗 Meal Plan\n\n"
+                formatted += f"{meal_plan}\n\n"
+            
+            # Add footer
+            formatted += "## 📊 Additional Information\n\n"
+            formatted += "- Plan created with AI assistance\n"
+            formatted += "- Customize as needed for your preferences\n"
+            formatted += "- Consult healthcare providers for medical advice\n\n"
+            formatted += "---\n"
+            formatted += "*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"**Error Formatting Plan Object**\n\n{str(e)}"
+
+    @staticmethod
+    def _format_training_plan(training_plan: Any) -> str:
+        """Format a TrainingPlan object."""
+        try:
+            formatted = ""
+            
+            # Get training plan details
+            plan_name = getattr(training_plan, 'name', 'Training Plan')
+            plan_description = getattr(training_plan, 'description', '')
+            goal_event = getattr(training_plan, 'goal_event', None)
+            target_event_date = getattr(training_plan, 'target_event_date', None)
+            total_duration_weeks = getattr(training_plan, 'total_duration_weeks', None)
+            
+            formatted += f"**{plan_name}**\n\n"
+            if plan_description:
+                formatted += f"{plan_description}\n\n"
+            
+            # Add goal event and timeline information
+            if goal_event:
+                formatted += f"**🎯 Target Event:** {goal_event}\n"
+            if target_event_date:
+                formatted += f"**📅 Target Date:** {target_event_date.strftime('%B %d, %Y')}\n"
+            if total_duration_weeks:
+                formatted += f"**⏱️ Total Duration:** {total_duration_weeks} weeks\n"
+            
+            if goal_event or target_event_date or total_duration_weeks:
+                formatted += "\n"
+            
+            # Format training splits with date ranges
+            training_splits = getattr(training_plan, 'training_plan_splits', [])
+            formatted += UIComponents._format_training_splits_with_dates(training_splits, target_event_date)
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error formatting training plan: {str(e)}"
+
+    @staticmethod
+    def _format_training_splits_with_dates(training_splits: list, target_event_date: Any = None) -> str:
+        """Format training splits with calculated date ranges."""
+        try:
+            from datetime import date, timedelta
+            
+            formatted = ""
+            current_date = date.today()
+            
+            # Sort splits by order
+            sorted_splits = sorted(training_splits, key=lambda x: getattr(x, 'order', 0))
+            
+            for split in sorted_splits:
+                # Get split details
+                split_name = getattr(split, 'name', 'Training Split')
+                phase_name = getattr(split, 'phase_name', split_name)
+                phase_type = getattr(split, 'phase_type', None)
+                duration_weeks = getattr(split, 'duration_weeks', 1)
+                split_start_date = getattr(split, 'start_date', None)
+                
+                # Calculate start date for this split
+                if split_start_date:
+                    start_date = split_start_date
+                else:
+                    start_date = current_date
+                
+                # Calculate end date
+                end_date = start_date + timedelta(weeks=duration_weeks) - timedelta(days=1)
+                
+                # Update current_date for next split
+                current_date = end_date + timedelta(days=1)
+                
+                # Format phase type emoji
+                phase_emojis = {
+                    'base_building': '🏗️',
+                    'strength': '💪',
+                    'power': '⚡',
+                    'peak': '🔥',
+                    'taper': '📉',
+                    'recovery': '😌',
+                    'maintenance': '⚖️'
+                }
+                phase_type_str = str(phase_type).replace('PhaseType.', '').lower() if phase_type else 'training'
+                phase_emoji = phase_emojis.get(phase_type_str, '📅')
+                
+                # Format the split header with date range
+                formatted += f"### {phase_emoji} {phase_name}\n"
+                formatted += f"**📅 Duration:** {start_date.strftime('%b %d')} - {end_date.strftime('%b %d, %Y')} ({duration_weeks} week{'s' if duration_weeks != 1 else ''})\n\n"
+                
+                # Add split description and training days
+                formatted += UIComponents._format_training_split_content(split)
+                formatted += "\n"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error formatting training splits with dates: {str(e)}"
+
+    @staticmethod
+    def _format_training_split(split: Any) -> str:
+        """Format a TrainingPlanSplit object (legacy method, use _format_training_splits_with_dates for new formatting)."""
+        try:
+            formatted = ""
+            
+            # Get split details
+            split_name = getattr(split, 'name', 'Training Split')
+            split_description = getattr(split, 'description', '')
+            
+            formatted += f"### 📅 {split_name}\n\n"
+            if split_description:
+                formatted += f"{split_description}\n\n"
+            
+            # Format training days
+            training_days = getattr(split, 'training_days', [])
+            for day in training_days:
+                formatted += UIComponents._format_training_day(day)
+                formatted += "\n"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error formatting training split: {str(e)}"
+
+    @staticmethod
+    def _format_training_split_content(split: Any) -> str:
+        """Format the content of a TrainingPlanSplit object (without header/dates)."""
+        try:
+            formatted = ""
+            
+            # Get split details
+            split_description = getattr(split, 'description', '')
+            
+            if split_description:
+                formatted += f"*{split_description}*\n\n"
+            
+            # Format training days
+            training_days = getattr(split, 'training_days', [])
+            for day in training_days:
+                formatted += UIComponents._format_training_day(day)
+                formatted += "\n"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error formatting training split content: {str(e)}"
+
+    @staticmethod 
+    def _format_training_day(day: Any) -> str:
+        """Format a TrainingDay object."""
+        try:
+            formatted = ""
+            
+            # Get day details
+            day_name = getattr(day, 'name', 'Training Day')
+            day_description = getattr(day, 'description', '')
+            day_order = getattr(day, 'order_number', '')
+            is_rest_day = getattr(day, 'rest_day', False)
+            day_intensity = getattr(day, 'intensity', None)
+            
+            # Format day header
+            day_emoji = "😴" if is_rest_day else "💪"
+            formatted += f"#### {day_emoji} Day {day_order}: {day_name}\n\n"
+            
+            if day_description:
+                formatted += f"*{day_description}*\n\n"
+            
+            if day_intensity and not is_rest_day:
+                intensity_emojis = {
+                    'light': '🟢',
+                    'moderate': '🟡', 
+                    'heavy': '🔴',
+                    'max_effort': '🔥'
+                }
+                intensity_str = str(day_intensity).replace('IntensityLevel.', '').replace('<', '').replace('>', '').split(':')[0]
+                intensity_emoji = intensity_emojis.get(intensity_str.lower(), '⚪')
+                formatted += f"**Intensity:** {intensity_emoji} {intensity_str.title()}\n\n"
+            
+            # Format exercises
+            if not is_rest_day:
+                exercises = getattr(day, 'exercises', [])
+                if exercises:
+                    formatted += "**Exercises:**\n\n"
+                    for i, exercise in enumerate(exercises, 1):
+                        formatted += UIComponents._format_exercise(exercise, i)
+                        formatted += "\n"
+            else:
+                formatted += "**Rest Day** - Focus on recovery, light stretching, or gentle activities.\n\n"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error formatting training day: {str(e)}"
+
+    @staticmethod
+    def _format_exercise(exercise: Any, number: int) -> str:
+        """Format an Exercise object."""
+        try:
+            # Get exercise details
+            name = getattr(exercise, 'name', 'Exercise')
+            description = getattr(exercise, 'description', '')
+            sets = getattr(exercise, 'sets', None)
+            reps = getattr(exercise, 'reps', None)
+            duration = getattr(exercise, 'duration', None)
+            intensity = getattr(exercise, 'intensity', None)
+            
+            formatted = f"{number}. **{name}**\n"
+            
+            # Add sets/reps/duration info
+            workout_details = []
+            if sets:
+                workout_details.append(f"{sets} sets")
+            if reps:
+                workout_details.append(f"{reps} reps")
+            if duration:
+                workout_details.append(f"{duration}s")
+            
+            if workout_details:
+                formatted += f"   *{' × '.join(workout_details)}*"
+                
+            if intensity:
+                intensity_emojis = {
+                    'light': '🟢',
+                    'moderate': '🟡',
+                    'heavy': '🔴', 
+                    'max_effort': '🔥'
+                }
+                intensity_str = str(intensity).replace('IntensityLevel.', '').replace('<', '').replace('>', '').split(':')[0]
+                intensity_emoji = intensity_emojis.get(intensity_str.lower(), '⚪')
+                formatted += f" - {intensity_emoji} {intensity_str.title()}"
+            
+            formatted += "\n"
+            
+            if description:
+                formatted += f"   *{description}*\n"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error formatting exercise: {str(e)}"
+
+    @staticmethod
+    def _format_structured_plan_string(plan_str: str) -> str:
+        """Format a string representation of a structured fitness plan."""
+        try:
+            import re
+            
+            # Extract plan name
+            name_match = re.search(r"🏋️\s*([^\n]*?)Training Plan", plan_str)
+            if not name_match:
+                name_match = re.search(r"name='([^']*)'", plan_str)
+            plan_name = name_match.group(1).strip() if name_match else "Fitness Plan"
+            
+            # Extract meal plan section
+            meal_match = re.search(r"🥗 Meal Plan\n(.*?)(?=📊|$)", plan_str, re.DOTALL)
+            meal_plan = meal_match.group(1).strip() if meal_match else ""
+            
+            # Extract training plan section with structured data
+            formatted = f"# 🏋️ {plan_name}\n\n"
+            
+            # Parse and format the structured training data
+            training_match = re.search(r"training_plan_splits=\[(.*?)\]\]", plan_str, re.DOTALL)
+            if training_match:
+                formatted += "## 💪 Training Plan\n\n"
+                formatted += UIComponents._parse_and_format_training_data(training_match.group(1))
+            
+            # Add meal plan
+            if meal_plan:
+                formatted += "\n## 🥗 Meal Plan\n\n"
+                formatted += f"{meal_plan}\n\n"
+            
+            # Add footer
+            formatted += "## 📊 Additional Information\n\n"
+            formatted += "- Plan created with AI assistance\n"
+            formatted += "- Customize as needed for your preferences\n"
+            formatted += "- Consult healthcare providers for medical advice\n\n"
+            formatted += "---\n"
+            formatted += "*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"**Error Parsing Structured Plan**\n\n{str(e)}\n\nRaw content:\n{plan_str}"
+
+    @staticmethod
+    def _parse_and_format_training_data(training_data: str) -> str:
+        """Parse and format the training data from string representation."""
+        try:
+            import re
+            
+            formatted = ""
+            
+            # Extract split information
+            split_name_match = re.search(r"name='([^']*)'", training_data)
+            split_name = split_name_match.group(1) if split_name_match else "Weekly Split"
+            
+            split_desc_match = re.search(r"description='([^']*)'", training_data)
+            split_desc = split_desc_match.group(1) if split_desc_match else ""
+            
+            formatted += f"**{split_name}**\n\n"
+            if split_desc:
+                formatted += f"{split_desc}\n\n"
+            
+            # Extract training days
+            days_pattern = r"TrainingDay\((.*?)\)(?=, TrainingDay\(|$)"
+            days = re.findall(days_pattern, training_data, re.DOTALL)
+            
+            for day_data in days:
+                formatted += UIComponents._parse_and_format_day_data(day_data)
+                formatted += "\n"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error parsing training data: {str(e)}"
+
+    @staticmethod
+    def _parse_and_format_day_data(day_data: str) -> str:
+        """Parse and format a single training day from string representation."""
+        try:
+            import re
+            
+            # Extract day details
+            name_match = re.search(r"name='([^']*)'", day_data)
+            day_name = name_match.group(1) if name_match else "Training Day"
+            
+            order_match = re.search(r"order_number=(\d+)", day_data)
+            day_order = order_match.group(1) if order_match else "1"
+            
+            desc_match = re.search(r"description='([^']*)'", day_data)
+            day_description = desc_match.group(1) if desc_match else ""
+            
+            rest_match = re.search(r"rest_day=(\w+)", day_data)
+            is_rest_day = rest_match and rest_match.group(1) == "True"
+            
+            intensity_match = re.search(r"intensity=<IntensityLevel\.(\w+):", day_data)
+            day_intensity = intensity_match.group(1) if intensity_match else None
+            
+            # Format day header
+            day_emoji = "😴" if is_rest_day else "💪"
+            formatted = f"#### {day_emoji} Day {day_order}: {day_name}\n\n"
+            
+            if day_description:
+                formatted += f"*{day_description}*\n\n"
+            
+            if day_intensity and not is_rest_day:
+                intensity_emojis = {
+                    'LIGHT': '🟢',
+                    'MODERATE': '🟡',
+                    'HEAVY': '🔴',
+                    'MAX_EFFORT': '🔥'
+                }
+                intensity_emoji = intensity_emojis.get(day_intensity, '⚪')
+                formatted += f"**Intensity:** {intensity_emoji} {day_intensity.title()}\n\n"
+            
+            # Parse exercises if not rest day
+            if not is_rest_day and 'exercises=[' in day_data:
+                exercises_match = re.search(r"exercises=\[(.*?)\]", day_data, re.DOTALL)
+                if exercises_match:
+                    exercises_data = exercises_match.group(1)
+                    formatted += "**Exercises:**\n\n"
+                    formatted += UIComponents._parse_and_format_exercises(exercises_data)
+            elif is_rest_day:
+                formatted += "**Rest Day** - Focus on recovery, light stretching, or gentle activities.\n\n"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error parsing day data: {str(e)}"
+
+    @staticmethod
+    def _parse_and_format_exercises(exercises_data: str) -> str:
+        """Parse and format exercises from string representation."""
+        try:
+            import re
+            
+            formatted = ""
+            
+            # Extract individual exercises
+            exercise_pattern = r"Exercise\((.*?)\)(?=, Exercise\(|$)"
+            exercises = re.findall(exercise_pattern, exercises_data, re.DOTALL)
+            
+            for i, exercise_data in enumerate(exercises, 1):
+                # Extract exercise details
+                name_match = re.search(r"name='([^']*)'", exercise_data)
+                name = name_match.group(1) if name_match else "Exercise"
+                
+                desc_match = re.search(r"description='([^']*)'", exercise_data)
+                description = desc_match.group(1) if desc_match else ""
+                
+                sets_match = re.search(r"sets=(\d+)", exercise_data)
+                sets = sets_match.group(1) if sets_match else None
+                
+                reps_match = re.search(r"reps=(\d+)", exercise_data)
+                reps = reps_match.group(1) if reps_match else None
+                
+                duration_match = re.search(r"duration=(\d+)", exercise_data)
+                duration = duration_match.group(1) if duration_match else None
+                
+                intensity_match = re.search(r"intensity=<IntensityLevel\.(\w+):", exercise_data)
+                intensity = intensity_match.group(1) if intensity_match else None
+                
+                # Format exercise
+                formatted += f"{i}. **{name}**\n"
+                
+                # Add workout details
+                workout_details = []
+                if sets:
+                    workout_details.append(f"{sets} sets")
+                if reps:
+                    workout_details.append(f"{reps} reps")
+                if duration:
+                    workout_details.append(f"{duration}s")
+                
+                if workout_details:
+                    formatted += f"   *{' × '.join(workout_details)}*"
+                
+                if intensity:
+                    intensity_emojis = {
+                        'LIGHT': '🟢',
+                        'MODERATE': '🟡',
+                        'HEAVY': '🔴',
+                        'MAX_EFFORT': '🔥'
+                    }
+                    intensity_emoji = intensity_emojis.get(intensity, '⚪')
+                    formatted += f" - {intensity_emoji} {intensity.title()}"
+                
+                formatted += "\n"
+                
+                if description:
+                    formatted += f"   *{description}*\n"
+                
+                formatted += "\n"
+            
+            return formatted
+            
+        except Exception as e:
+            return f"Error parsing exercises: {str(e)}"

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

@@ -7,6 +7,7 @@ import os
 from typing import List, Dict, Union, Generator, Any, Tuple, Optional
 
 from fitness_core.agents import FitnessAgent
+from fitness_core.agents.providers import ModelProvider
 from fitness_core.services import ConversationManager, FitnessAgentRunner, ResponseFormatter
 from fitness_core.utils import get_logger
 from .tts_utils import generate_speech_for_text, generate_speech_for_session, clean_tts_markup
@@ -24,7 +25,7 @@ logger = get_logger(__name__)
 # Global state management
 conversation_manager = ConversationManager()
 current_agent = None
-current_model = "llama-3.3-70b-versatile"
+current_model = ModelProvider.resolve_model_name()  # Use configured default model
 
 
 class UIHandlers:

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

@@ -339,7 +339,7 @@ MODEL_COMPARISON_CONTENT = """
 - llama-3.3-70b-versatile, mixtral-8x7b-32768
 
 **✅ GOOD for Fitness Plans (may need more specific prompting):**
-- claude-3.5-haiku, gpt-4o-mini, gpt-3.5-turbo
+- gpt-4o, claude-3.5-haiku, gpt-4o-mini, gpt-3.5-turbo
 - llama3-70b-8192, qwen3-32b, kimi-k2-instruct
 
 **⚠️ LIMITED for Complex Plans (basic guidance only):**
@@ -350,11 +350,11 @@ MODEL_COMPARISON_CONTENT = """
 - gemma-7b-it (may produce incomplete or empty plans)
 
 ### 🎯 Recommendations by Use Case
-- **Quick questions**: claude-3.5-haiku, gpt-4o-mini, gpt-3.5-turbo, any Groq model
-- **Comprehensive fitness plans**: claude-3.5-sonnet+, gpt-4o+, llama-3.3-70b-versatile, mixtral-8x7b-32768
-- **Complex analysis**: claude-4-opus, gpt-4o, o1-preview
-- **Budget-conscious**: claude-3-haiku, gpt-3.5-turbo, gpt-4o-mini
-- **Speed priority**: Any Groq model, claude-3.5-haiku, gpt-4o-mini
+- **Quick questions**: gpt-4o, claude-3.5-haiku, gpt-4o-mini, gpt-3.5-turbo, any Groq model
+- **Comprehensive fitness plans**: gpt-4o+, claude-3.5-sonnet+, llama-3.3-70b-versatile, mixtral-8x7b-32768
+- **Complex analysis**: gpt-4o, claude-4-opus, o1-preview
+- **Budget-conscious**: gpt-4o-mini, claude-3-haiku, gpt-3.5-turbo
+- **Speed priority**: Any Groq model, gpt-4o-mini, claude-3.5-haiku
 
 ### 🔧 Troubleshooting Complex Tasks
 If you experience **empty or incomplete fitness plans** with smaller models:

apps/gradio-app/src/fitness_gradio/ui/voice_conversation.py

@@ -19,6 +19,7 @@ except ImportError:
 
 from fitness_core.utils import get_logger
 from fitness_core.agents import FitnessAgent
+from fitness_core.agents.providers import ModelProvider
 from fitness_core.services import FitnessAgentRunner, ConversationManager
 from fitness_core.services.formatters import ResponseFormatter
 from .tts_utils import generate_speech_for_session, clean_tts_markup
@@ -181,7 +182,7 @@ class VoiceConversationManager:
         """
         try:
             # Create a fitness agent for this conversation
-            agent = FitnessAgent(model_name or "llama-3.3-70b-versatile")
+            agent = FitnessAgent(model_name or ModelProvider.resolve_model_name())
             
             # Get input for agent from conversation manager (same as text chat)
             agent_input = conversation_manager.get_input_for_agent()

shared/src/fitness_core/agents/providers.py

@@ -114,8 +114,15 @@ class ModelProvider:
     def get_recommended_models(cls) -> List[str]:
         """Get a list of recommended models that are most likely to be available."""
         return [
-            # Groq recommendations (fast and cost-effective) - now default
-            "llama-3.3-70b-versatile", # Latest and most capable Llama model - DEFAULT
+            # OpenAI recommendations (now default)
+            "gpt-4o",                  # Latest flagship model - NEW DEFAULT
+            "gpt-4o-mini",             # Best balance of capability and cost
+            "gpt-3.5-turbo",          # Most cost-effective OpenAI model
+            "gpt-4-turbo",            # Solid previous generation
+            "o1-mini",                # Good reasoning capabilities
+            
+            # Groq recommendations (fast and cost-effective)
+            "llama-3.3-70b-versatile", # Latest and most capable Llama model
             "llama-3.1-8b-instant",   # Fastest for simple tasks
             "gemma2-9b-it",           # Efficient Google model
             "mixtral-8x7b-32768",     # Excellent reasoning with large context
@@ -126,13 +133,6 @@ class ModelProvider:
             "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 
@@ -363,15 +363,15 @@ class ModelProvider:
                 os.getenv("ANTHROPIC_MODEL") or 
                 os.getenv("OPENAI_MODEL") or 
                 os.getenv("GROQ_MODEL") or
-                "llama-3.3-70b-versatile"  # Default fallback - latest Groq Llama model for excellent performance
+                "gpt-4o"  # Default fallback - OpenAI's flagship model for excellent performance
             )
         
         # 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: llama-3.3-70b-versatile")
-            model_name = "llama-3.3-70b-versatile"
+            print(f"Falling back to default model: gpt-4o")
+            model_name = "gpt-4o"
         
         return model_name
 

shared/src/fitness_core/agents/structured_output_models.py

@@ -9,6 +9,7 @@ from enum import Enum
 
 class IntensityLevel(str, Enum):
     """Intensity levels for exercises."""
+    REST = "rest"
     LIGHT = "light"
     MODERATE = "moderate"
     HEAVY = "heavy"
@@ -20,14 +21,17 @@ class Exercise(BaseModel):
     name: str = Field(
         description="The name of the exercise (e.g., 'Push-ups', 'Squats', 'Deadlift')"
     )
-    description: Optional[str] = Field(
-        default=None,
+    description: str = Field(
         description="Brief description of how to perform the exercise, including proper form and technique"
     )
     duration: Optional[int] = Field(
         default=None,
         description="Duration of the exercise in seconds (for time-based exercises like planks or cardio)"
     )
+    distance: Optional[float] = Field(
+        default=None,
+        description="Distance to be covered in meters (for running, cycling, etc.)"
+    )
     sets: Optional[int] = Field(
         default=None,
         description="Number of sets to perform for this exercise (e.g., 3 sets). Used for strength training and resistance exercises."
@@ -36,7 +40,7 @@ class Exercise(BaseModel):
         default=None,
         description="Number of repetitions per set (e.g., 10 reps). Used for strength training exercises. Can be a range like '8-12' for variety."
     )
-    intensity: Optional[IntensityLevel] = Field(
+    intensity: IntensityLevel = Field(
         default=None,
         description="Intensity level of the exercise. 'light' for warm-up/mobility work, 'moderate' for general training, 'heavy' for strength focus (80-90% effort), 'max_effort' for testing/competition lifts. Can be left blank for rest days or exercises where intensity is not applicable."
     )
@@ -53,63 +57,65 @@ class TrainingDay(BaseModel):
     description: str = Field(
         description="Brief overview of the day's focus and training objectives (e.g., 'Focus on compound upper body movements with moderate intensity')"
     )
-    exercises: Optional[List[Exercise]] = Field(  # Made optional
-        default=None,
-        description="List of exercises to be performed on this training day, with full details including sets, reps, and intensity. Leave empty/null for complete rest days."
+    exercises: List[Exercise] = Field(
+        description="List of exercises to be performed on this training day, with full details including sets, reps, and intensity. Include good rest activities for complete rest days."
     )
-    intensity: Optional[IntensityLevel] = Field(
-        default=None,
+    intensity: IntensityLevel = Field(
         description="Overall intensity of the training day. Use 'light' for recovery/mobility, 'moderate' for standard training, 'heavy' for strength focus, 'max_effort' for testing. Leave blank for complete rest days."
     )
-    rest_day: bool = Field(
-        default=False,
-        description="True if this is a complete rest day with no exercises"
-    )
-
 
-class TrainingPlanSplit(BaseModel):
-    """A training split represents a complete cycle of training days (e.g., a weekly routine)."""
+class TrainingSplit(BaseModel):
+    """A training split represents a complete cycle of training days within a specific periodization phase."""
     name: str = Field(
         description="Descriptive name for the split approach (e.g., 'Push/Pull/Legs Split', 'Upper/Lower Split', 'Full Body Circuit')"
     )
-    order: int = Field(
-        description="Sequential order when multiple splits are used in periodization (1 for first phase, 2 for second phase, etc.)"
-    )
     description: str = Field(
-        description="Detailed explanation of the split's training philosophy, target muscle groups, and how days are organized"
-    )
-    start_date: Optional[date] = Field(
-        default=None,
-        description="Optional start date for this specific split. If not provided, will be calculated based on previous splits. Useful for precise scheduling of periodized programs."
+        description="Detailed explanation of the split's training philosophy, target muscle groups, how days are organized, and how this phase fits into the overall periodization strategy"
     )
     training_days: List[TrainingDay] = Field(
-        description="All training days in the split, ordered sequentially. Include rest days for complete weekly schedules."
+        description="All training days in the training split, ordered sequentially. Make sure to include all the rest days needed in the split."
     )
 
+class TrainingPeriod(BaseModel):
+    name: str = Field(
+        description="Descriptive name for the period (e.g., 'Base Phase', 'Advanced Phase', 'Preparation Phase')"
+    )
+    description: str = Field(
+        description="Overview of the period's focus, training goals, and how it fits into the overall plan"
+    )
+    start_date: date = Field(
+        description="Start date for this specific training period."
+    )
+    intensity: IntensityLevel = Field(
+        description="Overall intensity level for this period. Use 'light' for recovery, 'moderate' for general training, 'heavy' for strength focus, 'max_effort' for testing, 'rest' for complete rest."
+    )
+    training_split: TrainingSplit = Field(
+        description="The training split that will be followed during this period. Should include all training days and rest days as the schedule will be created assuming a rolling schedule of training splits."
+    )
 
 class TrainingPlan(BaseModel):
-    """Complete training plan containing one or more training splits."""
+    """Complete periodized training plan with progressive phases leading to a target goal/event."""
     name: str = Field(
-        description="Catchy name that reflects the plan's focus (e.g., 'Beginner Strength Foundation', 'Advanced Powerlifting Prep')"
+        description="Name that reflects the plan's focus and target event"
     )
     description: str = Field(
-        description="Comprehensive overview including training philosophy, progression strategy, target audience, and expected timeline"
+        description="Comprehensive overview including training philosophy, periodization strategy, target audience, expected timeline, and how the phases progress toward the goal"
     )
-    training_plan_splits: List[TrainingPlanSplit] = Field(
-        description="Ordered list of training splits. Single split for consistent routines, multiple splits for periodized programs with distinct phases (base building → strength → peaking)"
+    training_periods: List[TrainingPeriod] = Field(
+        description="Ordered list of TrainingPeriod objects representing different phases of the training plan."
     )
 
 
 class FitnessPlan(BaseModel):
     """Structured fitness plan model for LLM output."""
     name: str = Field(
-        description="Catchy, descriptive name for the fitness plan (e.g., 'Beginner Strength Builder', '30-Day Fat Loss Challenge')"
+        description="Name for the fitness plan"
     )
     goal: str = Field(
-        description="Primary goal of the fitness plan (e.g., 'Build muscle', 'Lose weight', 'Improve endurance'). Should be specific and measurable."
+        description="Primary goal of the fitness plan"
     )
     description: str = Field(
-        description="Comprehensive overview of the fitness plan, including goals, target audience, and expected outcomes"
+        description="Comprehensive overview of the fitness plan, including a brief overview of how the training plan and meal plan meet the goal."
     )
     training_plan: TrainingPlan = Field(
         description="The training plan includes all of the workout splits, training days, and exercises"
@@ -117,11 +123,10 @@ class FitnessPlan(BaseModel):
     meal_plan: str = Field(
         description="Detailed nutrition guidance including meal suggestions, macronutrient targets, and eating schedule. Should be practical and specific to the fitness goals."
     )
-    start_date: Optional[date] = Field(
+    start_date: date = Field(
         default_factory=lambda: date.today(),
         description="The date when the user should start this fitness plan"
     )
-    target_date: Optional[date] = Field(
-        default=None,
-        description="Optional target completion date or milestone date for the fitness plan"
+    target_date: date = Field(
+        description="The target completion date or milestone date for the fitness plan"
     )

shared/src/fitness_core/agents/tools.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from datetime import date, timedelta
 from agents import function_tool, RunContextWrapper
 
-from .structured_output_models import FitnessPlan, TrainingDay
+from .structured_output_models import FitnessPlan, TrainingDay, IntensityLevel
 
 
 @dataclass
@@ -46,44 +46,44 @@ def build_fitness_schedule(fitness_plan: FitnessPlan, start_date: Optional[date]
     schedule = []
     current_date = start_date
     
-    # Sort splits by order to ensure proper sequencing
-    sorted_splits = sorted(fitness_plan.training_plan.training_plan_splits, key=lambda x: x.order)
-    
-    for split in sorted_splits:
-        # Use split's start_date if provided, otherwise use current_date
-        split_start_date = split.start_date if split.start_date else current_date
-        split_current_date = split_start_date
+    # Process training periods in order
+    for period in fitness_plan.training_plan.training_periods:
+        # Use period's start_date if provided, otherwise use current_date
+        period_start_date = period.start_date if period.start_date else current_date
+        period_current_date = period_start_date
+        
+        # Get the training split for this period
+        training_split = period.training_split
         
         # Calculate how many days this split's cycle is
         week_number = 1
         
-        # Continue cycling through the split until we reach the end date or run out of splits
-        while (end_date is None or split_current_date <= end_date):
-            for day_idx, training_day in enumerate(split.training_days):
+        # Continue cycling through the split until we reach the end date or move to next period
+        while (end_date is None or period_current_date <= end_date):
+            for day_idx, training_day in enumerate(training_split.training_days):
                 # Stop if we've reached the end date
-                if end_date and split_current_date > end_date:
+                if end_date and period_current_date > end_date:
                     break
                     
                 scheduled_day = ScheduledTrainingDay(
-                    date=split_current_date,
+                    date=period_current_date,
                     training_day=training_day,
-                    split_name=split.name,
+                    split_name=training_split.name,
                     week_number=week_number,
                     day_in_week=day_idx + 1
                 )
                 schedule.append(scheduled_day)
-                split_current_date += timedelta(days=1)
+                period_current_date += timedelta(days=1)
             
             # Increment week number after completing a full cycle
             week_number += 1
             
-            # If this is the last split and we don't have an end date, break after one cycle
-            # to avoid infinite loops
-            if end_date is None and split == sorted_splits[-1]:
-                break
+            # For now, break after one cycle of the split to move to next period
+            # TODO: Add logic to determine when to move to next period based on duration
+            break
         
-        # Update current_date for the next split (if no explicit start_date is set for next split)
-        current_date = split_current_date
+        # Update current_date for the next period
+        current_date = period_current_date
     
     return schedule
 
@@ -123,7 +123,12 @@ def format_schedule_summary(schedule: List[ScheduledTrainingDay], days_to_show:
         day_str = scheduled_day.date.strftime("%a, %b %d")
         intensity_str = f" ({scheduled_day.training_day.intensity.value})" if scheduled_day.training_day.intensity else ""
         
-        if scheduled_day.training_day.rest_day:
+        # Check if this is a rest day (no exercises or rest intensity)
+        is_rest_day = (not scheduled_day.training_day.exercises or 
+                      len(scheduled_day.training_day.exercises) == 0 or
+                      (scheduled_day.training_day.intensity and scheduled_day.training_day.intensity.value == "rest"))
+        
+        if is_rest_day:
             summary_lines.append(f"• {day_str}: {scheduled_day.training_day.name}")
         else:
             exercise_count = len(scheduled_day.training_day.exercises) if scheduled_day.training_day.exercises else 0
@@ -216,16 +221,42 @@ FITNESS_TOOLS = {
         function=create_fitness_plan,
         prompt_instructions="""
         When the user requests a fitness plan, use the create_fitness_plan tool with a fully completed FitnessPlan object.
-        
+
+        Fitness Plans are made up of Training Plans and Meal Plans that have a start and end date.
+        If no start date is specified, assume the plan starts today.
+        If no end date is given by the user assume they want a plan to be in better shape in 3 months.
+
         The FitnessPlan object must include:
         - name: A descriptive name for the fitness plan
-        - goal: The primary fitness goal
-        - training_plan: Detailed training/workout information with splits and days
-        - meal_plan: Comprehensive nutrition and meal planning details
+        - goal: The primary fitness goal (should be specific and measurable)
+        - description: Comprehensive overview of the plan and expected outcomes
+        - training_plan: A TrainingPlan object with periodized phases that includes:
+          * name: Name that reflects the plan's focus and target event
+          * description: Comprehensive overview including training philosophy, periodization strategy, target audience, expected timeline, and how the phases progress toward the goal
+          * training_periods: Ordered list of TrainingPeriod objects representing different phases:
+            - Each period should have a name (e.g., 'Base Phase', 'Advanced Phase', 'Preparation Phase')
+            - Include start_date for each period
+            - Include intensity level (rest, light, moderate, heavy, max_effort)
+            - Each period contains a training_split with training_days that include exercises
+            - Follow periodization principles: typically base building → peak training → recovery for optimum performance at events
+            - Each phase should build on the previous with appropriate progression
+        - meal_plan: Detailed nutrition guidance including meal suggestions, macronutrient targets, and eating schedule. Should be practical and specific to the fitness goals.
         - start_date: When the plan should begin (defaults to today)
-        - target_date: Optional end date for the plan
+        - target_date: The target completion date or milestone date for the fitness plan
 
-        This tool automatically builds a date-based schedule and saves the plan to the FitnessAgent class.
+        Training Structure:
+        - TrainingPeriod contains a TrainingSplit
+        - TrainingSplit contains multiple TrainingDay objects
+        - TrainingDay contains multiple Exercise objects
+        - Each Exercise should have name, description, and appropriate fields (sets, reps, duration, distance, intensity)
+        - Include rest days in the training split as needed
+
+        Create periodized plans that progress intelligently toward the goal:
+        - For events (hikes, competitions): Use base building → strength → peak → taper progression
+        - For aesthetic goals (summer body): Use muscle building → strength → cutting/definition phases
+        - For general fitness: Use base building → strength → maintenance cycles
+        
+        This tool automatically builds a date-based schedule from the periodized phases and saves the plan.
 
         Do not read the plan back to the user in the conversation. The user can already see it in the UI component.
 

shared/src/fitness_core/services/formatters.py

@@ -24,7 +24,16 @@ class ResponseFormatter:
             Formatted markdown string
         """
         try:
-            if not (hasattr(plan_obj, 'name') and 
+            # First, try to handle structured FitnessPlan objects
+            if hasattr(plan_obj, 'name') and hasattr(plan_obj, 'training_plan'):
+                return ResponseFormatter._format_structured_fitness_plan(plan_obj, style)
+            
+            # Handle string representation of structured objects  
+            elif isinstance(plan_obj, str) and 'training_plan_splits=' in plan_obj:
+                return ResponseFormatter._format_structured_plan_string(plan_obj, style)
+            
+            # Legacy handling for older format objects
+            elif 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
@@ -42,6 +51,7 @@ class ResponseFormatter:
                 else:
                     return f"**Fitness Plan**\n\n{str(plan_obj)}"
             
+            # Legacy formatting for basic objects
             if style == "minimal":
                 return f"""**{plan_obj.name}**
 
@@ -82,6 +92,403 @@ class ResponseFormatter:
             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 _format_structured_fitness_plan(plan_obj: Any, style: str = "default") -> str:
+        """Format a structured FitnessPlan object with proper training plan formatting."""
+        try:
+            # Extract basic plan info
+            plan_name = getattr(plan_obj, 'name', 'Fitness Plan')
+            plan_goal = getattr(plan_obj, 'goal', '')
+            plan_description = getattr(plan_obj, 'description', '')
+            meal_plan = getattr(plan_obj, 'meal_plan', '')
+            
+            # Format header
+            formatted = f"# 🏋️ {plan_name}\n\n"
+            
+            if plan_goal:
+                formatted += f"**🎯 Goal:** {plan_goal}\n\n"
+            
+            if plan_description:
+                formatted += f"**📋 Overview:** {plan_description}\n\n"
+            
+            # Format training plan
+            training_plan = getattr(plan_obj, 'training_plan', None)
+            if training_plan:
+                formatted += "## 💪 Training Plan\n\n"
+                formatted += ResponseFormatter._format_training_plan_object(training_plan)
+            
+            # Format meal plan
+            if meal_plan:
+                formatted += "\n## 🥗 Meal Plan\n\n"
+                formatted += f"{meal_plan}\n\n"
+            
+            # Add footer based on style
+            if style in ["detailed", "default"]:
+                formatted += "## 📊 Additional Information\n\n"
+                formatted += "- Plan created with AI assistance\n"
+                formatted += "- Customize as needed for your preferences\n"  
+                formatted += "- Consult healthcare providers for medical advice\n\n"
+                formatted += "---\n"
+                formatted += "*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error formatting structured fitness plan: {str(e)}")
+            return f"**Error Formatting Plan**\n\n{str(e)}"
+
+    @staticmethod
+    def _format_training_plan_object(training_plan: Any) -> str:
+        """Format a TrainingPlan object with proper structure."""
+        try:
+            formatted = ""
+            
+            # Get training plan details
+            plan_name = getattr(training_plan, 'name', 'Training Plan')
+            plan_description = getattr(training_plan, 'description', '')
+            
+            formatted += f"**{plan_name}**\n\n"
+            if plan_description:
+                formatted += f"{plan_description}\n\n"
+            
+            # Format training splits
+            training_splits = getattr(training_plan, 'training_plan_splits', [])
+            for split in training_splits:
+                formatted += ResponseFormatter._format_training_split_object(split)
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error formatting training plan object: {str(e)}")
+            return f"Error formatting training plan: {str(e)}"
+
+    @staticmethod
+    def _format_training_split_object(split: Any) -> str:
+        """Format a TrainingPlanSplit object."""
+        try:
+            formatted = ""
+            
+            # Get split details
+            split_name = getattr(split, 'name', 'Training Split')
+            split_description = getattr(split, 'description', '')
+            
+            formatted += f"### 📅 {split_name}\n\n"
+            if split_description:
+                formatted += f"{split_description}\n\n"
+            
+            # Format training days
+            training_days = getattr(split, 'training_days', [])
+            for day in training_days:
+                formatted += ResponseFormatter._format_training_day_object(day)
+                formatted += "\n"
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error formatting training split object: {str(e)}")
+            return f"Error formatting training split: {str(e)}"
+
+    @staticmethod 
+    def _format_training_day_object(day: Any) -> str:
+        """Format a TrainingDay object."""
+        try:
+            formatted = ""
+            
+            # Get day details
+            day_name = getattr(day, 'name', 'Training Day')
+            day_description = getattr(day, 'description', '')
+            day_order = getattr(day, 'order_number', '')
+            is_rest_day = getattr(day, 'rest_day', False)
+            day_intensity = getattr(day, 'intensity', None)
+            
+            # Format day header
+            day_emoji = "😴" if is_rest_day else "💪"
+            formatted += f"#### {day_emoji} Day {day_order}: {day_name}\n\n"
+            
+            if day_description:
+                formatted += f"*{day_description}*\n\n"
+            
+            if day_intensity and not is_rest_day:
+                intensity_emojis = {
+                    'light': '🟢', 'LIGHT': '🟢',
+                    'moderate': '🟡', 'MODERATE': '🟡',
+                    'heavy': '🔴', 'HEAVY': '🔴',
+                    'max_effort': '🔥', 'MAX_EFFORT': '🔥'
+                }
+                # Handle both enum objects and string representations
+                intensity_str = str(day_intensity).replace('IntensityLevel.', '').replace('<', '').replace('>', '').split(':')[0]
+                intensity_emoji = intensity_emojis.get(intensity_str, '⚪')
+                formatted += f"**Intensity:** {intensity_emoji} {intensity_str.title()}\n\n"
+            
+            # Format exercises
+            if not is_rest_day:
+                exercises = getattr(day, 'exercises', [])
+                if exercises:
+                    formatted += "**Exercises:**\n\n"
+                    for i, exercise in enumerate(exercises, 1):
+                        formatted += ResponseFormatter._format_exercise_object(exercise, i)
+                        formatted += "\n"
+            else:
+                formatted += "**Rest Day** - Focus on recovery, light stretching, or gentle activities.\n\n"
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error formatting training day object: {str(e)}")
+            return f"Error formatting training day: {str(e)}"
+
+    @staticmethod
+    def _format_exercise_object(exercise: Any, number: int) -> str:
+        """Format an Exercise object."""
+        try:
+            # Get exercise details
+            name = getattr(exercise, 'name', 'Exercise')
+            description = getattr(exercise, 'description', '')
+            sets = getattr(exercise, 'sets', None)
+            reps = getattr(exercise, 'reps', None)
+            duration = getattr(exercise, 'duration', None)
+            intensity = getattr(exercise, 'intensity', None)
+            
+            formatted = f"{number}. **{name}**\n"
+            
+            # Add sets/reps/duration info
+            workout_details = []
+            if sets:
+                workout_details.append(f"{sets} sets")
+            if reps:
+                workout_details.append(f"{reps} reps")
+            if duration:
+                workout_details.append(f"{duration}s")
+            
+            if workout_details:
+                formatted += f"   *{' × '.join(workout_details)}*"
+                
+            if intensity:
+                intensity_emojis = {
+                    'light': '🟢', 'LIGHT': '🟢',
+                    'moderate': '🟡', 'MODERATE': '🟡',
+                    'heavy': '🔴', 'HEAVY': '🔴',
+                    'max_effort': '🔥', 'MAX_EFFORT': '🔥'
+                }
+                # Handle both enum objects and string representations
+                intensity_str = str(intensity).replace('IntensityLevel.', '').replace('<', '').replace('>', '').split(':')[0]
+                intensity_emoji = intensity_emojis.get(intensity_str, '⚪')
+                formatted += f" - {intensity_emoji} {intensity_str.title()}"
+            
+            formatted += "\n"
+            
+            if description:
+                formatted += f"   *{description}*\n"
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error formatting exercise object: {str(e)}")
+            return f"Error formatting exercise: {str(e)}"
+
+    @staticmethod
+    def _format_structured_plan_string(plan_str: str, style: str = "default") -> str:
+        """Format a string representation of a structured fitness plan."""
+        try:
+            import re
+            
+            # Extract plan name
+            name_match = re.search(r"🏋️\s*([^\n]*?)Training Plan", plan_str)
+            if not name_match:
+                name_match = re.search(r"name='([^']*)'", plan_str)
+            plan_name = name_match.group(1).strip() if name_match else "Fitness Plan"
+            
+            # Extract meal plan section
+            meal_match = re.search(r"🥗 Meal Plan\n(.*?)(?=📊|$)", plan_str, re.DOTALL)
+            meal_plan = meal_match.group(1).strip() if meal_match else ""
+            
+            # Extract training plan section with structured data
+            formatted = f"# 🏋️ {plan_name}\n\n"
+            
+            # Parse and format the structured training data
+            training_match = re.search(r"training_plan_splits=\[(.*?)\]\]", plan_str, re.DOTALL)
+            if training_match:
+                formatted += "## 💪 Training Plan\n\n"
+                formatted += ResponseFormatter._parse_and_format_training_data(training_match.group(1))
+            
+            # Add meal plan
+            if meal_plan:
+                formatted += "\n## 🥗 Meal Plan\n\n"
+                formatted += f"{meal_plan}\n\n"
+            
+            # Add footer based on style
+            if style in ["detailed", "default"]:
+                formatted += "## 📊 Additional Information\n\n"
+                formatted += "- Plan created with AI assistance\n"
+                formatted += "- Customize as needed for your preferences\n"
+                formatted += "- Consult healthcare providers for medical advice\n\n"
+                formatted += "---\n"
+                formatted += "*Your personalized fitness plan is ready! Feel free to ask any questions about the plan or request modifications.*"
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error parsing structured plan string: {str(e)}")
+            return f"**Error Parsing Structured Plan**\n\n{str(e)}\n\nRaw content:\n{plan_str}"
+
+    @staticmethod
+    def _parse_and_format_training_data(training_data: str) -> str:
+        """Parse and format the training data from string representation."""
+        try:
+            import re
+            
+            formatted = ""
+            
+            # Extract split information
+            split_name_match = re.search(r"name='([^']*)'", training_data)
+            split_name = split_name_match.group(1) if split_name_match else "Weekly Split"
+            
+            split_desc_match = re.search(r"description='([^']*)'", training_data)
+            split_desc = split_desc_match.group(1) if split_desc_match else ""
+            
+            formatted += f"**{split_name}**\n\n"
+            if split_desc:
+                formatted += f"{split_desc}\n\n"
+            
+            # Extract training days
+            days_pattern = r"TrainingDay\((.*?)\)(?=, TrainingDay\(|$)"
+            days = re.findall(days_pattern, training_data, re.DOTALL)
+            
+            for day_data in days:
+                formatted += ResponseFormatter._parse_and_format_day_data(day_data)
+                formatted += "\n"
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error parsing training data: {str(e)}")
+            return f"Error parsing training data: {str(e)}"
+
+    @staticmethod
+    def _parse_and_format_day_data(day_data: str) -> str:
+        """Parse and format a single training day from string representation."""
+        try:
+            import re
+            
+            # Extract day details
+            name_match = re.search(r"name='([^']*)'", day_data)
+            day_name = name_match.group(1) if name_match else "Training Day"
+            
+            order_match = re.search(r"order_number=(\d+)", day_data)
+            day_order = order_match.group(1) if order_match else "1"
+            
+            desc_match = re.search(r"description='([^']*)'", day_data)
+            day_description = desc_match.group(1) if desc_match else ""
+            
+            rest_match = re.search(r"rest_day=(\w+)", day_data)
+            is_rest_day = rest_match and rest_match.group(1) == "True"
+            
+            intensity_match = re.search(r"intensity=<IntensityLevel\.(\w+):", day_data)
+            day_intensity = intensity_match.group(1) if intensity_match else None
+            
+            # Format day header
+            day_emoji = "😴" if is_rest_day else "💪"
+            formatted = f"#### {day_emoji} Day {day_order}: {day_name}\n\n"
+            
+            if day_description:
+                formatted += f"*{day_description}*\n\n"
+            
+            if day_intensity and not is_rest_day:
+                intensity_emojis = {
+                    'LIGHT': '🟢',
+                    'MODERATE': '🟡',
+                    'HEAVY': '🔴',
+                    'MAX_EFFORT': '🔥'
+                }
+                intensity_emoji = intensity_emojis.get(day_intensity, '⚪')
+                formatted += f"**Intensity:** {intensity_emoji} {day_intensity.title()}\n\n"
+            
+            # Parse exercises if not rest day
+            if not is_rest_day and 'exercises=[' in day_data:
+                exercises_match = re.search(r"exercises=\[(.*?)\]", day_data, re.DOTALL)
+                if exercises_match:
+                    exercises_data = exercises_match.group(1)
+                    formatted += "**Exercises:**\n\n"
+                    formatted += ResponseFormatter._parse_and_format_exercises(exercises_data)
+            elif is_rest_day:
+                formatted += "**Rest Day** - Focus on recovery, light stretching, or gentle activities.\n\n"
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error parsing day data: {str(e)}")
+            return f"Error parsing day data: {str(e)}"
+
+    @staticmethod
+    def _parse_and_format_exercises(exercises_data: str) -> str:
+        """Parse and format exercises from string representation."""
+        try:
+            import re
+            
+            formatted = ""
+            
+            # Extract individual exercises
+            exercise_pattern = r"Exercise\((.*?)\)(?=, Exercise\(|$)"
+            exercises = re.findall(exercise_pattern, exercises_data, re.DOTALL)
+            
+            for i, exercise_data in enumerate(exercises, 1):
+                # Extract exercise details
+                name_match = re.search(r"name='([^']*)'", exercise_data)
+                name = name_match.group(1) if name_match else "Exercise"
+                
+                desc_match = re.search(r"description='([^']*)'", exercise_data)
+                description = desc_match.group(1) if desc_match else ""
+                
+                sets_match = re.search(r"sets=(\d+)", exercise_data)
+                sets = sets_match.group(1) if sets_match else None
+                
+                reps_match = re.search(r"reps=(\d+)", exercise_data)
+                reps = reps_match.group(1) if reps_match else None
+                
+                duration_match = re.search(r"duration=(\d+)", exercise_data)
+                duration = duration_match.group(1) if duration_match else None
+                
+                intensity_match = re.search(r"intensity=<IntensityLevel\.(\w+):", exercise_data)
+                intensity = intensity_match.group(1) if intensity_match else None
+                
+                # Format exercise
+                formatted += f"{i}. **{name}**\n"
+                
+                # Add workout details
+                workout_details = []
+                if sets:
+                    workout_details.append(f"{sets} sets")
+                if reps:
+                    workout_details.append(f"{reps} reps")
+                if duration:
+                    workout_details.append(f"{duration}s")
+                
+                if workout_details:
+                    formatted += f"   *{' × '.join(workout_details)}*"
+                
+                if intensity:
+                    intensity_emojis = {
+                        'LIGHT': '🟢',
+                        'MODERATE': '🟡',
+                        'HEAVY': '🔴',
+                        'MAX_EFFORT': '🔥'
+                    }
+                    intensity_emoji = intensity_emojis.get(intensity, '⚪')
+                    formatted += f" - {intensity_emoji} {intensity.title()}"
+                
+                formatted += "\n"
+                
+                if description:
+                    formatted += f"   *{description}*\n"
+                
+                formatted += "\n"
+            
+            return formatted
+            
+        except Exception as e:
+            logger.error(f"Error parsing exercises: {str(e)}")
+            return f"Error parsing exercises: {str(e)}"
+
     @staticmethod
     def parse_fitness_plan_from_string(plan_str: str) -> str:
         """

shared/src/fitness_core/utils/config.py

@@ -18,7 +18,7 @@ class Config:
     DEBUG: bool = os.getenv("DEBUG", "false").lower() == "true"
     
     # AI Model configuration
-    DEFAULT_MODEL: str = os.getenv("AI_MODEL", os.getenv("OPENAI_MODEL", "llama-3.3-70b-versatile"))
+    DEFAULT_MODEL: str = os.getenv("AI_MODEL", os.getenv("OPENAI_MODEL", "gpt-4o"))
     ANTHROPIC_API_KEY: Optional[str] = os.getenv("ANTHROPIC_API_KEY")
     OPENAI_API_KEY: Optional[str] = os.getenv("OPENAI_API_KEY")
     

test_formatting.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+Test script for structured fitness plan formatting
+"""
+
+# Sample structured output from your example
+sample_output = """🏋️ Intermediate Muscle Hypertrophy Accelerator
+💪 Training Plan
+name='Muscle Hypertrophy Split' description='A 5-day split targeting different muscle groups with high volume and strategic intensity progression to maximize muscle growth.' training_plan_splits=[TrainingPlanSplit(name='Muscle Building Weekly Split', order=1, description='Advanced split focusing on targeted muscle group development with progressive overload techniques', start_date=datetime.date(2024, 2, 15), training_days=[TrainingDay(name='Chest and Triceps Day', order_number=1, description='High-volume chest and triceps workout with compound and isolation movements', exercises=[Exercise(name='Barbell Bench Press', description='Perform with a controlled tempo, focusing on chest muscle engagement', duration=None, sets=4, reps=8, intensity=<IntensityLevel.HEAVY: 'heavy'>), Exercise(name='Incline Dumbbell Press', description='Focus on full range of motion and mind-muscle connection', duration=None, sets=3, reps=10, intensity=<IntensityLevel.MODERATE: 'moderate'>), Exercise(name='Tricep Pushdowns', description='Keep elbows close to body, use a controlled movement', duration=None, sets=3, reps=12, intensity=<IntensityLevel.MODERATE: 'moderate'>)], intensity=<IntensityLevel.HEAVY: 'heavy'>, rest_day=False), TrainingDay(name='Back and Biceps Day', order_number=2, description='Comprehensive back and biceps muscle development workout', exercises=[Exercise(name='Deadlifts', description='Maintain proper form, engage core and back muscles', duration=None, sets=4, reps=6, intensity=<IntensityLevel.HEAVY: 'heavy'>), Exercise(name='Pull-ups', description='Use full range of motion, can use assisted pull-up machine if needed', duration=None, sets=3, reps=8, intensity=<IntensityLevel.MODERATE: 'moderate'>), Exercise(name='Barbell Curls', description='Controlled movement, focus on bicep contraction', duration=None, sets=3, reps=10, intensity=<IntensityLevel.MODERATE: 'moderate'>)], intensity=<IntensityLevel.HEAVY: 'heavy'>, rest_day=False), TrainingDay(name='Leg Day', order_number=3, description='Intense lower body workout targeting quads, hamstrings, and glutes', exercises=[Exercise(name='Barbell Squats', description='Maintain proper depth and form, engage core', duration=None, sets=4, reps=8, intensity=<IntensityLevel.HEAVY: 'heavy'>), Exercise(name='Romanian Deadlifts', description='Focus on hamstring stretch and contraction', duration=None, sets=3, reps=10, intensity=<IntensityLevel.MODERATE: 'moderate'>), Exercise(name='Leg Press', description='Full range of motion, controlled tempo', duration=None, sets=3, reps=12, intensity=<IntensityLevel.MODERATE: 'moderate'>)], intensity=<IntensityLevel.HEAVY: 'heavy'>, rest_day=False), TrainingDay(name='Shoulder Day', order_number=4, description='Comprehensive shoulder muscle development with varied movements', exercises=[Exercise(name='Overhead Military Press', description='Strict form, engage core for stability', duration=None, sets=4, reps=8, intensity=<IntensityLevel.HEAVY: 'heavy'>), Exercise(name='Lateral Raises', description='Controlled movement, avoid swinging', duration=None, sets=3, reps=12, intensity=<IntensityLevel.MODERATE: 'moderate'>), Exercise(name='Face Pulls', description='Focus on rear deltoid engagement', duration=None, sets=3, reps=15, intensity=<IntensityLevel.LIGHT: 'light'>)], intensity=<IntensityLevel.HEAVY: 'heavy'>, rest_day=False), TrainingDay(name='Arms and Core Day', order_number=5, description='Targeted arm muscle development with core strengthening', exercises=[Exercise(name='Close Grip Bench Press', description='Emphasize tricep engagement', duration=None, sets=3, reps=10, intensity=<IntensityLevel.MODERATE: 'moderate'>), Exercise(name='Hammer Curls', description='Controlled bicep curl variation', duration=None, sets=3, reps=12, intensity=<IntensityLevel.MODERATE: 'moderate'>), Exercise(name='Planks', description='Maintain proper form, engage entire core', duration=60, sets=3, reps=None, intensity=<IntensityLevel.MODERATE: 'moderate'>)], intensity=<IntensityLevel.MODERATE: 'moderate'>, rest_day=False), TrainingDay(name='Rest and Recovery', order_number=6, description='Complete rest day for muscle recovery and growth', exercises=None, intensity=None, rest_day=True), TrainingDay(name='Rest and Recovery', order_number=7, description='Complete rest day for muscle recovery and growth', exercises=None, intensity=None, rest_day=True)])]
+
+🥗 Meal Plan
+High-protein diet focusing on lean proteins, complex carbohydrates, and healthy fats. Aim for 1.6-2.2g of protein per kg of body weight. Consume 300-500 calories above maintenance level. Meal examples: Chicken breast with brown rice and vegetables, salmon with sweet potato, protein smoothies, egg white omelets with whole grain toast. Supplement with whey protein and creatine monohydrate.
+
+📊 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."""
+
+# Import the formatter
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'shared', 'src'))
+
+from fitness_core.services.formatters import ResponseFormatter
+
+# Test the formatter
+print("=== Testing Structured Fitness Plan Formatting ===\n")
+
+try:
+    formatted_result = ResponseFormatter.format_fitness_plan(sample_output, style="detailed")
+    print("FORMATTED OUTPUT:")
+    print(formatted_result)
+except Exception as e:
+    print(f"Error: {e}")
+    print(f"Raw input: {sample_output[:200]}...")