Liftin'

Create a standalone ad-hoc routine (outside any program, available for training right away). IMPORTANT: present the proposed routine and get the user's explicit approval BEFORE calling. Exercises use the update_routine NEW-entry format: {exerciseID, sets, trainingMaxKg? or trainingMaxLbs?, restSeconds?, warmup?, autoProgression?} or {superset: [entries], restBetweenExercises?} (a superset's members share ONE rest timer — restSeconds on any member sets it for the group, and restBetweenExercises: true fires it between every exercise of the round rather than only after the last) — same set format and weight rules as update_exercise_plans (weightKg OR weightLbs per set — assistanceKg/assistanceLbs on ASSISTED exercises, a positive amount the machine takes off — weights REQUIRED on loaded exercises, taken from the user's history or conservatively estimated), and the same autoProgression format for automatic progression rules (only with the user's approval).

create_ad_hoc_routine

Create a custom exercise. ONLY after search_exercises or list_exercises found no match — most exercises exist under alternative names. Every exercise needs an equipment_type (ask the user if unclear) — the server assigns a sensible default equipment for it; the user can fine-tune the exact equipment in the app. Get the user's approval before creating.

create_exercise

Create a complete new workout program in one atomic operation. IMPORTANT: present the full proposed program and get the user's explicit approval BEFORE calling. Most programs are a rotation of routines with NO week structure (e.g. 5x5 alternating A/B) — use 'routines'. Only genuinely week-based programs (different content per week, e.g. 5/3/1 cycles) use 'weeks'. Pick exercises from ONE list_exercises call (not repeated searches). Exercises use the update_routine entry format ({exerciseID, sets, trainingMaxKg? or trainingMaxLbs?, restSeconds?, warmup?, autoProgression?} and {superset: [...], restBetweenExercises?}); each set: ONE rep target (targetReps number | targetRepRange {min, max} | amrap: true | amrapMinReps) OR durationSeconds, plus optionally weightKg OR weightLbs (exactly one; either unit accepted and converted), trainingMaxPercentage, targetRPE/targetRIR, weightByFeel, dropPercentage; ASSISTED exercises (marked [.., assisted] in list_exercises — a machine that takes weight OFF the user) take assistanceKg/assistanceLbs and trainingMaxAssistanceKg/Lbs instead, positive amounts of assistance (0 = full bodyweight, more = easier), and reject the weight keys; restSeconds sets the exercise's rest timer (0 = off, omitted = app default) — inside a superset it sets the group's ONE shared rest timer, fired after the last exercise of each round, and restBetweenExercises: true on the superset makes it fire between every exercise instead; warmup toggles app-generated warmup sets (omitted = default by equipment). AUTO PROGRESSION: when the program the user describes implies progression rules — 'add 2.5kg every workout' (linear), 'work up from 8 to 12 reps then add weight' (double progression), 'deload 10% after 3 failed sessions' — OFFER auto progression in the proposal: the app then adjusts weights/reps/sets automatically from workout results. Include an autoProgression object per exercise (same format as update_exercise_plans' autoProgression field) ONLY when the user approves; without it the plan is static. CRITICAL: carry EVERY detail of the approved plan on EVERY set of EVERY exercise — omitted fields are dropped silently (e.g. leaving out targetRPE/weightByFeel stores that exercise without its effort target); do NOT abbreviate later exercises, weeks or routines. WEIGHTS ARE REQUIRED on every set of loaded (non-bodyweight) exercises — omitting one is rejected. BEFORE proposing the program, look up the user's recent weights for each exercise with get_exercise_history (ONE call, all exercises) and use similar loads. For exercises with NO history, estimate CONSERVATIVE starting weights from the user's performance on similar logged exercises (or typical beginner loads), mark them as estimates in the proposal, ask afterwards whether to adjust, and mention that weights are easy to adjust in the app if too light or heavy. weightByFeel (RPE/RIR-based loading) is an ADVANCED technique: use it ONLY when the user asked for it or the program design is explicitly effort-based — NEVER as a fallback for unknown weights. Weights snap to each equipment's increments. The same exercise appearing multiple times automatically shares one training max, and instances with IDENTICAL settings are LINKED (one shared plan, changes mirror between them — e.g. Squat in 5x5's A and B routines); instances with different settings (e.g. weekly progression) stay separate. The new program is NOT auto-selected — the user selects it in the app.

create_program

Get the user's currently selected workout programs (primary and optional secondary) with their routines, plus their standalone ad-hoc routines (adHocRoutines — always available for training, not part of any program). Multi-week programs group routines per week. Each program's upNextRoutineID names the routine the user will train next — fetch its details with get_routines. Use this when the user asks about their program, plan, routines, or what's coming up.

get_active_programs

Exercise-focused history: the logged results of specific exercises across ALL their workouts, newest first — the right tool for progression questions ('how is my squat and bench progressing'), PRs, and picking weights for a plan. Pass ALL wanted exercises in ONE call via exercise_ids (from search_exercises or list_exercises) — never one call per exercise. Returns, per exercise, dated entries with the tracked work sets (weights, reps, effort) and training max; warmup sets are excluded. For whole workouts use get_workout_history instead.

get_exercise_history

Get ONE program by id with its routines — including programs the user is NOT currently training (get_active_programs only covers the selected ones). Same shape as a program there: id, name, upNextRoutineID, and routines, or weeks with their routines for multi-week programs. Use ids from list_programs, then get_routines for a routine's exercises. Reading a program NEVER requires selecting it — do not call set_active_program just to look at one.

get_program

Get one or MORE routines' full plans in a single call — pass ALL the routine ids you need at once (e.g. every routine of a program when analyzing it), never one call per routine. Returns each routine's exercises with their planned sets (weight, rep targets or duration), in the order requested. Every weight field carries its unit in the key (weightKg/weightLbs, trainingMaxKg/trainingMaxLbs) — per exercise, matching the user's display unit. An exercise flagged assisted: true is an ASSISTED machine (assisted pull-ups/dips) that takes weight OFF the user: its sets carry assistanceKg/assistanceLbs and its training max trainingMaxAssistanceKg/trainingMaxAssistanceLbs — positive amounts of assistance, higher = easier, 0 = full bodyweight — instead of the weight keys, and writes must use the same keys. On those exercises a dropset shows only its dropPercentage (the app derives the load from the user's bodyweight, which is not part of the plan). Entries in an exercises list are either a plain exercise or a superset ({superset: [exercises]}) whose exercises are performed back to back. Each exercise's restSeconds is the rest timer between sets (0 = timer off; omitted = timer on with the app's default duration); inside a superset it is the group's SHARED rest timer, taken after the last exercise of each round, and restBetweenExercises: true means it is taken between every exercise instead; warmup says whether the app generates warmup sets before the exercise (which sets is app-side configuration). exerciseNote, when present, is the user's own note on that EXERCISE — shared by every routine and program using it, not specific to this plan (set or delete it via update_exercise_plans). An exercise may carry autoProgression — the app's automatic progression rules (absent = auto progression off for that exercise; set, changed or turned off via update_exercise_plans's autoProgression field): onSuccess fires after afterConsecutiveSuccesses consecutive successful workouts, onFailure after afterConsecutiveFailures consecutive failed ones — both omitted when 1, i.e. on EVERY successful/failed workout (success = every set hit its targets; criteria: 'heaviestSet' appears when only the heaviest set counts). Each rule has exactly ONE action. progressionAction = an object with exactly one key: weightIncrementKg or weightIncrementLbs (fixed amount, exercise's display unit), weightIncrementPercent, repsIncrement, timeIncrementSeconds, or addSet: true — on onFailure the keys are weightDecrementKg/weightDecrementLbs/weightDecrementPercent, repsDecrement, timeDecrementSeconds. doubleProgressionAction = repRange {min, max, repsPerStep (omitted = 1)} with atMaxReps (each trigger adds repsPerStep reps; at max reps the atMaxReps weight increment applies and reps reset to min), or setRange {min, max} with atMaxSets (each trigger adds one set; at max sets the atMaxSets increment applies and sets reset to min). Two ADVANCED rules exist for specific program styles: conditionedIncreaseAction (onSuccess; 5/3/1-style) = {keySet, conditions: [{minRepsAboveTarget, weightIncrementKg or weightIncrementLbs}]} — keySet is the 1-based index of an AMRAP set among the exercise's sets; after a success, the reps achieved BEYOND that set's minimum select the highest satisfied condition, whose weight increment applies (more extra reps = bigger jump). progressSetsAction (onFailure) = {levels: [{sets, reps}], afterLastLevel} — each trigger moves the plan to the next sets×reps level (e.g. 5×3 → 6×2 → 10×1); failing at the last level resets to level 1 applying afterLastLevel: {weightDecrementKg/Lbs/Percent} (drop the weight), {useLevel1Weight: true} (back to the weight used at level 1), {useLevel1WeightPlusKg/Lbs/Percent} (level-1 weight increased), or {adjustWeightManually: true} (user sets the weight in the app). TRAINING MAX exercises (useTrainingMax=true): weight progression adjusts the TRAINING MAX, not per-set weights — all weight keys read as their trainingMax… variants instead (trainingMaxIncrementKg/Lbs/Percent, trainingMaxDecrement…, useLevel1TrainingMax[Plus…], adjustTrainingMaxManually); say 'training max' when presenting those rules to the user. updateAfterFullCycle: true = a triggered change waits until the program cycle's last routine before applying (omitted = false, changes apply right after the workout; true is for multi-week programs like 5/3/1 where a mid-cycle change — e.g. to the training max — would alter the weights of upcoming planned workouts). IMPORTANT: when auto progression is active, the app adjusts this exercise's plan on its own — factor that in before proposing manual weight/rep changes, and never re-implement its progression by hand. Use routine ids from get_active_programs, get_program (any program, active or not) or list_ad_hoc_routines.

get_routines

Get full workout history — workouts WITH their exercises and set data (weights, reps, goals) inlined. Use this when the user asks about exercises/sets across one or more workouts, e.g. 'my last 5 workouts' or 'my workouts in June'. Target specific workouts by passing their ids as workout_ids (from list_workouts) — ONE call for all of them, never a call per workout. For a quick list without set details use list_workouts; for specific exercises' progression across workouts use get_exercise_history.

get_workout_history

List the user's standalone ad-hoc routines — routines outside any program, always available for training (get_active_programs includes them too). Use get_routines for a routine's exercises, update_routine to edit them, create_ad_hoc_routine for a new one; REMOVING an ad-hoc routine happens in the app, not here.

list_ad_hoc_routines

List EVERY exercise the user can train: the app's full catalog grouped by primary muscle, plus their custom exercises — with the exerciseID to use in other tools. Compact and cheap: when designing or building a program (or picking from what exists), call this ONCE and choose from the list instead of many search_exercises calls. Exercises tagged [.., assisted] are assisted machines that take weight OFF the user: their sets take assistanceKg/assistanceLbs (positive = weight removed), never weightKg/weightLbs.

list_exercises