🤖 Auto-deploy from GitHub (push) - 45aa088 - 2025-08-05 00:26:50 UTC

shared/src/fitness_core/agents/fitness_agent.py

@@ -5,7 +5,8 @@ from typing import Optional
 from agents import Agent
 from dotenv import load_dotenv
 
-from .models import FitnessPlan, AgentConfig
+from .models import AgentConfig
+from .structured_output_models import FitnessPlan
 from .providers import ModelProvider
 from .tools import get_tool_functions, get_combined_instructions
 
@@ -53,7 +54,13 @@ class FitnessAgent(Agent):
 
             You create personalized plans by iteratively creating plans and asking the user for feedback.
 
-            You provide short, concise responses in conversation.
+            Create the first plan as soon as the user asks for a fitness plan, and then iterate on it based on their feedback.
+
+            Never ask for feedback before creating a new plan based on what you already know.
+
+            You provide short, concise responses in conversation, generally no longer than one or two sentences.
+
+            Unless specified otherwise, do not respond with any lists or bullet points. Talk like a normal person.
 
             {tool_instructions}
 

shared/src/fitness_core/agents/models.py

@@ -1,15 +1,10 @@
 """
 Pydantic models for the fitness agent.
 """
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from typing import Optional, List
-
-
-class FitnessPlan(BaseModel):
-    """Structured fitness plan model."""
-    name: str
-    training_plan: str
-    meal_plan: str
+from datetime import datetime, date
+from .structured_output_models import FitnessPlan
 
 
 class AgentResponse(BaseModel):

shared/src/fitness_core/agents/structured_output_models.py

@@ -0,0 +1,127 @@
+"""
+Pydantic models for structured LLM outputs.
+"""
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from datetime import date
+from enum import Enum
+
+
+class IntensityLevel(str, Enum):
+    """Intensity levels for exercises."""
+    LIGHT = "light"
+    MODERATE = "moderate"
+    HEAVY = "heavy"
+    MAX_EFFORT = "max_effort"
+
+
+class Exercise(BaseModel):
+    """Model for a single exercise."""
+    name: str = Field(
+        description="The name of the exercise (e.g., 'Push-ups', 'Squats', 'Deadlift')"
+    )
+    description: Optional[str] = Field(
+        default=None,
+        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)"
+    )
+    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."
+    )
+    reps: Optional[int] = Field(
+        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(
+        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."
+    )
+
+
+class TrainingDay(BaseModel):
+    """Model for a single training day."""
+    name: str = Field(
+        description="Descriptive name for the training day (e.g., 'Upper Body Strength', 'Cardio & Core', 'Active Recovery', 'Rest Day')"
+    )
+    order_number: int = Field(
+        description="The sequential position of this day within the split (1-7 for weekly splits)"
+    )
+    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."
+    )
+    intensity: Optional[IntensityLevel] = Field(
+        default=None,
+        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)."""
+    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."
+    )
+    training_days: List[TrainingDay] = Field(
+        description="All training days in the split, ordered sequentially. Include rest days for complete weekly schedules."
+    )
+
+
+class TrainingPlan(BaseModel):
+    """Complete training plan containing one or more training splits."""
+    name: str = Field(
+        description="Catchy name that reflects the plan's focus (e.g., 'Beginner Strength Foundation', 'Advanced Powerlifting Prep')"
+    )
+    description: str = Field(
+        description="Comprehensive overview including training philosophy, progression strategy, target audience, and expected timeline"
+    )
+    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)"
+    )
+
+
+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')"
+    )
+    goal: str = Field(
+        description="Primary goal of the fitness plan (e.g., 'Build muscle', 'Lose weight', 'Improve endurance'). Should be specific and measurable."
+    )
+    description: str = Field(
+        description="Comprehensive overview of the fitness plan, including goals, target audience, and expected outcomes"
+    )
+    training_plan: TrainingPlan = Field(
+        description="The training plan includes all of the workout splits, training days, and exercises"
+    )
+    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(
+        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"
+    )

shared/src/fitness_core/agents/tools.py

@@ -3,9 +3,11 @@ Fitness agent tools with grouped function and prompt definitions.
 """
 from typing import Optional, Any, Dict, List
 from dataclasses import dataclass
+from datetime import date, timedelta
 from agents import function_tool, RunContextWrapper
 
 from .models import FitnessPlan
+from .structured_output_models import TrainingDay
 
 
 @dataclass
@@ -15,6 +17,123 @@ class FunctionToolConfig:
     prompt_instructions: str
 
 
+@dataclass
+class ScheduledTrainingDay:
+    """A training day with an assigned date."""
+    date: date
+    training_day: TrainingDay
+    split_name: str
+    week_number: int
+    day_in_week: int
+
+
+def build_fitness_schedule(fitness_plan: FitnessPlan, start_date: Optional[date] = None) -> List[ScheduledTrainingDay]:
+    """
+    Build a date-based schedule from a fitness plan.
+    
+    Args:
+        fitness_plan: The FitnessPlan object to create a schedule from
+        start_date: Optional start date, defaults to fitness_plan.start_date or today
+    
+    Returns:
+        List of ScheduledTrainingDay objects with assigned dates
+    """
+    if start_date is None:
+        start_date = fitness_plan.start_date or date.today()
+    
+    # Use target_date as end_date if available
+    end_date = fitness_plan.target_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
+        
+        # Calculate how many days this split's cycle is
+        days_per_cycle = len(split.training_days)
+        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):
+                # Stop if we've reached the end date
+                if end_date and split_current_date > end_date:
+                    break
+                    
+                scheduled_day = ScheduledTrainingDay(
+                    date=split_current_date,
+                    training_day=training_day,
+                    split_name=split.name,
+                    week_number=week_number,
+                    day_in_week=day_idx + 1
+                )
+                schedule.append(scheduled_day)
+                split_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
+        
+        # Update current_date for the next split (if no explicit start_date is set for next split)
+        current_date = split_current_date
+    
+    return schedule
+
+
+def format_schedule_summary(schedule: List[ScheduledTrainingDay], days_to_show: int = 14) -> str:
+    """
+    Format the schedule into a readable summary showing upcoming training days.
+    
+    Args:
+        schedule: List of ScheduledTrainingDay objects
+        days_to_show: Number of upcoming days to display
+    
+    Returns:
+        Formatted string showing the schedule
+    """
+    if not schedule:
+        return "No scheduled training days found."
+    
+    # Show only upcoming days (from today forward)
+    today = date.today()
+    upcoming_days = [day for day in schedule if day.date >= today][:days_to_show]
+    
+    if not upcoming_days:
+        return "No upcoming training days scheduled."
+    
+    summary_lines = ["**Upcoming Training Schedule:**"]
+    current_week = None
+    
+    for scheduled_day in upcoming_days:
+        # Add week separator
+        week_key = f"{scheduled_day.split_name} - Week {scheduled_day.week_number}"
+        if week_key != current_week:
+            summary_lines.append(f"\n*{week_key}*")
+            current_week = week_key
+        
+        # Format the day
+        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:
+            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
+            summary_lines.append(f"• {day_str}: {scheduled_day.training_day.name}{intensity_str} ({exercise_count} exercises)")
+    
+    return "\n".join(summary_lines)
+
+
 @function_tool
 async def create_fitness_plan(
     ctx: RunContextWrapper[Any],
@@ -32,21 +151,67 @@ async def create_fitness_plan(
         # Save the fitness plan to the agent class
         FitnessAgent.set_latest_fitness_plan(fitness_plan)
         
+        # Build the schedule from the fitness plan
+        schedule = build_fitness_schedule(fitness_plan)
+        schedule_summary = format_schedule_summary(schedule)
+        
         # Format the plan for display
         formatted_plan = f"""**{fitness_plan.name}**
 
-**Training Plan:**
-{fitness_plan.training_plan}
+**Goal:** {fitness_plan.goal}
+
+**Training Plan:** {fitness_plan.training_plan.name}
+{fitness_plan.training_plan.description}
+
+{schedule_summary}
 
 **Meal Plan:**
 {fitness_plan.meal_plan}"""
         
-        return f"I've created and saved your personalized fitness plan:\n\n{formatted_plan}\n\nThis plan has been tailored specifically for your requirements and is now available in the fitness plan section below. Please consult with a healthcare provider before starting any new fitness program."
+        # Calculate duration for display
+        if fitness_plan.target_date and fitness_plan.start_date:
+            duration_days = (fitness_plan.target_date - fitness_plan.start_date).days
+            duration_weeks = duration_days // 7
+            duration_text = f"{duration_weeks}-week"
+        else:
+            duration_text = "customized"
+        
+        return f"I've created and saved your personalized fitness plan with a {duration_text} schedule:\n\n{formatted_plan}\n\nThis plan has been tailored specifically for your requirements and is now available in the fitness plan section below. Please consult with a healthcare provider before starting any new fitness program."
         
     except Exception as e:
         return f"I apologize, but I encountered an error while saving your fitness plan: {str(e)}. Please try again or contact support if the issue persists."
 
 
+@function_tool
+async def get_training_schedule(
+    ctx: RunContextWrapper[Any],
+    days_ahead: int = 14,
+) -> str:
+    """Get the upcoming training schedule from the current fitness plan.
+
+    Args:
+        days_ahead: Number of days ahead to show in the schedule (default: 14)
+    """
+    try:
+        # Import here to avoid circular imports
+        from .fitness_agent import FitnessAgent
+        
+        # Get the current fitness plan
+        fitness_plan = FitnessAgent.get_latest_fitness_plan()
+        
+        if not fitness_plan:
+            return "No fitness plan is currently available. Please create a fitness plan first."
+        
+        # Build and format the schedule
+        schedule = build_fitness_schedule(fitness_plan)
+        schedule_summary = format_schedule_summary(schedule, days_ahead)
+        
+        return f"Here's your upcoming training schedule:\n\n{schedule_summary}"
+        
+    except Exception as e:
+        return f"I encountered an error while retrieving your training schedule: {str(e)}. Please try again."
+
+
 # Tool configurations with their associated prompt instructions
 FITNESS_TOOLS = {
     "create_fitness_plan": FunctionToolConfig(
@@ -56,11 +221,27 @@ FITNESS_TOOLS = {
         
         The FitnessPlan object must include:
         - name: A descriptive name for the fitness plan
-        - training_plan: Detailed training/workout information
+        - goal: The primary fitness goal
+        - training_plan: Detailed training/workout information with splits and days
         - meal_plan: Comprehensive nutrition and meal planning details
+        - start_date: When the plan should begin (defaults to today)
+        - total_duration_weeks: Total duration of the plan
+
+        This tool automatically builds a date-based schedule and saves the plan to the FitnessAgent class.
 
-        This tool saves the plan to the FitnessAgent class, makes it available for UI display, and returns a formatted confirmation message.
-        Do not read the plan back to the user in the conversation as they can see it in the UI component.
+        Do not read the plan back to the user in the conversation. The user can already see it in the UI component.
+
+        In one or two sentences, let the user know the plan has been created, and ask the user if they want to make any adjustments.
+        """
+    ),
+    "get_training_schedule": FunctionToolConfig(
+        function=get_training_schedule,
+        prompt_instructions="""
+        Use this tool when the user asks about their upcoming workouts, training schedule, or what they should do on specific days.
+        
+        The tool shows the next 14 days by default, but you can specify a different number of days if the user requests it.
+        
+        This tool requires that a fitness plan has already been created.
         """
     )
 }