fix: repair health chat and rewrite the diet planner for Pakistani home food

Chat and diet only. Nothing else on this Space is touched.

Health chat was returning a generic apology for every message. The single
free model it called was failing with no retry and no alternative, so any
rate limit or model retirement took the feature down completely.

- OpenRouter client now sends a fallback chain (glm-4.5-air -> llama-3.3-70b
-> openrouter/free, capped at 3 because OpenRouter rejects longer chains
with a 400), retries 429/5xx with backoff honouring Retry-After, fails fast
on a bad key, handles HTTP 200 error bodies, and reads `reasoning` when
`content` comes back empty.
- Reasoning models on the free tier spend most of a small token budget
thinking and truncate the answer, so the diet request now asks for low,
excluded reasoning with real headroom, salvages complete days out of
truncated JSON, and tops a 5- or 6-day result up to 7 instead of discarding
it.
- Chat answers even when Supabase is unreachable; it just answers without
saved history rather than failing the request.
- Outages now return ok:false with a reason the UI can show, instead of a
silent apology that looks like a real reply. ChatResponse gains `ok` and
`error` for that.

Diet plans were suggesting oatmeal, quinoa and "protein salad bowl" — food
most households here do not recognise or buy. The prompt and the offline
fallback are rewritten around everyday home food (anda, roti, daal, chawal,
sabzi, dahi, kela) in plain language, in both English and Urdu. Generated
plans are rejected and replaced when they lean on unfamiliar ingredients,
break a stated restriction (egg, dairy, gluten, nuts — these may be
allergies), or contain food unsafe for the stated condition: a live run put
halwa puri in a diabetic plan.

Adapted for this Space: the routers here keep no rate limiting, since this
deployment has no slowapi, and config.py gains only the fallback-model
setting.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

app/config.py

@@ -21,6 +21,15 @@ class Settings(BaseSettings):
     # OpenRouter
     openrouter_api_key: str = ""
     openrouter_model: str = "z-ai/glm-4.5-air:free"
+    # Free model IDs get rate limited and retired without warning, which
+    # used to take the chatbot and diet planner offline. These are tried
+    # in order when the primary model fails. `openrouter/free` is
+    # OpenRouter's auto-router across whatever free models are healthy.
+    # Max 3 entries in total: OpenRouter rejects a longer chain with 400.
+    openrouter_fallback_models: str = (
+        "meta-llama/llama-3.3-70b-instruct:free,"
+        "openrouter/free"
+    )
     openrouter_site_url: str = "http://localhost:5173"
     openrouter_app_name: str = "XRayVision AI"
     openrouter_timeout_seconds: float = 60.0

app/models/schemas.py

@@ -125,6 +125,10 @@ class ChatResponse(BaseModel):
     reply: str
     doctor_type: Optional[str] = None
     home_remedies: list[str] = []
+    # False when the AI service could not be reached; `error` carries the reason
+    # so the UI can show it instead of silently pretending the bot replied.
+    ok: bool = True
+    error: Optional[str] = None
 
 
 class ChatSession(BaseModel):

app/routers/chat.py

@@ -1,6 +1,8 @@
 """Health chatbot endpoints — FYP requirement."""
 
-from __future__ import annotations
+import logging
+import uuid
+
 from fastapi import APIRouter, Depends, HTTPException, status
 from app.models.schemas import ChatRequest, ChatResponse, ChatSession
 from app.services.auth_service import get_current_user_id
@@ -13,6 +15,8 @@ from app.utils.supabase_client import (
     user_owns_chat_session,
 )
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/chat", tags=["chat"])
 
 
@@ -21,43 +25,92 @@ async def send_message(
     req: ChatRequest,
     user_id: str = Depends(get_current_user_id),
 ):
-    """Send a message to the health chatbot."""
-    # Create or use existing session
+    """Send a message to the health chatbot.
+
+    Chat history is a convenience, not the feature. If Supabase is unreachable
+    or the chat tables are missing, the bot still answers — it just answers
+    without saved history rather than failing the whole request.
+    """
+    message = (req.message or "").strip()
+    if not message:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Message cannot be empty.",
+        )
+
     session_id = req.session_id
-    if not session_id:
-        session = create_chat_session(user_id, title=req.message[:50])
-        session_id = session["id"]
-    elif not user_owns_chat_session(session_id, user_id):
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Chat session not found.")
+    persisted = True
+
+    if session_id:
+        try:
+            if not user_owns_chat_session(session_id, user_id):
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Chat session not found.",
+                )
+        except HTTPException:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Could not verify chat session ownership: %s", exc)
+            persisted = False
+    else:
+        try:
+            session = create_chat_session(user_id, title=message[:50])
+            session_id = session.get("id")
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Could not create chat session: %s", exc)
+            session_id = None
 
-    # Get conversation history for context
-    history = get_chat_messages(session_id, user_id)
+        if not session_id:
+            # Keep the conversation usable for this page load even with no DB.
+            session_id = str(uuid.uuid4())
+            persisted = False
 
-    # Save user message
-    insert_chat_message(session_id, "user", req.message)
+    history: list[dict] = []
+    if persisted:
+        try:
+            history = get_chat_messages(session_id, user_id)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Could not load chat history: %s", exc)
+
+        try:
+            insert_chat_message(session_id, "user", message)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Could not save user message: %s", exc)
+            persisted = False
 
-    # Get AI response
     result = chat_with_health_bot(
-        message=req.message,
+        message=message,
         conversation_history=history,
         language=req.language,
     )
 
-    # Save assistant response
-    insert_chat_message(session_id, "assistant", result["reply"])
+    # Only store real answers — don't pollute history with service outages.
+    if persisted and result.get("ok"):
+        try:
+            insert_chat_message(session_id, "assistant", result["reply"])
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Could not save assistant message: %s", exc)
 
     return ChatResponse(
         session_id=session_id,
         reply=result["reply"],
         doctor_type=result.get("doctor_type"),
         home_remedies=result.get("home_remedies", []),
+        ok=bool(result.get("ok", True)),
+        error=result.get("error"),
     )
 
 
 @router.get("/sessions", response_model=list[ChatSession])
 async def list_sessions(user_id: str = Depends(get_current_user_id)):
     """List all chat sessions for the user."""
-    sessions = get_chat_sessions(user_id)
+    try:
+        sessions = get_chat_sessions(user_id)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Could not list chat sessions: %s", exc)
+        return []
+
     return [
         ChatSession(
             id=s["id"],
@@ -74,5 +127,8 @@ async def get_messages(
     user_id: str = Depends(get_current_user_id),
 ):
     """Get all messages in a chat session."""
-    messages = get_chat_messages(session_id, user_id)
-    return messages
+    try:
+        return get_chat_messages(session_id, user_id)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Could not load chat messages: %s", exc)
+        return []

app/routers/diet.py

@@ -1,6 +1,5 @@
 """Diet plan generator endpoint — FYP requirement."""
 
-from __future__ import annotations
 from fastapi import APIRouter, Depends
 from app.models.schemas import DietRequest, DietPlanResponse, DayPlan, MealItem
 from app.services.auth_service import get_current_user_id

app/services/chatbot_service.py

@@ -1,17 +1,23 @@
-"""Health chatbot service powered by OpenRouter GLM 4.5 Air.
+"""Health chatbot service powered by OpenRouter.
 
 FYP requirement: General doctor bot for health queries, symptom analysis,
 home remedies, doctor type recommendation, and multilingual support.
+
+The bot answers in plain, everyday language for a Pakistani audience — no
+clinical jargon the average user would not recognise.
 """
 
 from __future__ import annotations
+
 import logging
-from app.services.openrouter_client import complete_text
+
+from app.services.openrouter_client import OpenRouterError, complete_chat
 
 logger = logging.getLogger(__name__)
 
 
-SYSTEM_PROMPT_EN = """You are XRayVision AI Health Assistant — a knowledgeable, empathetic medical chatbot.
+SYSTEM_PROMPT_EN = """You are the XRayVision AI Health Assistant — a knowledgeable, empathetic medical chatbot for users in Pakistan.
+
 You help patients with:
 1. Symptom analysis and possible conditions
 2. Basic home remedies and first-aid guidance
@@ -24,14 +30,19 @@ IMPORTANT RULES:
 - For serious symptoms, ALWAYS recommend visiting a hospital.
 - Be empathetic and clear in your responses.
 - If asked about medications, suggest consulting a pharmacist or doctor.
-- Provide evidence-based information when possible.
-- Keep responses concise but thorough (2-4 paragraphs max).
+- Keep responses short and simple: 2-4 short paragraphs at most.
+
+LANGUAGE RULES:
+- Write in simple, everyday English that someone with no medical background understands.
+- Avoid medical jargon. If you must use a medical term, explain it in brackets right after.
+- When you mention food, use everyday Pakistani household items — egg, roti, bread, rice,
+  daal, yogurt (dahi), banana, milk, chicken soup, tea — not foreign or unfamiliar ingredients.
 
-Respond in a structured, helpful manner. If you recommend a doctor type, mention it clearly.
-If you suggest home remedies, list them as bullet points.
+Respond in a structured, helpful manner.
 """
 
-SYSTEM_PROMPT_UR = """آپ XRayVision AI ہیلتھ اسسٹنٹ ہیں — ایک ذہین اور ہمدرد طبی چیٹ بوٹ۔
+SYSTEM_PROMPT_UR = """آپ XRayVision AI ہیلتھ اسسٹنٹ ہیں — پاکستانی صارفین کے لیے ایک ذہین اور ہمدرد طبی چیٹ بوٹ۔
+
 آپ مریضوں کی مدد کرتے ہیں:
 1. علامات کا تجزیہ اور ممکنہ بیماریاں
 2. بنیادی گھریلو علاج اور فرسٹ ایڈ
@@ -42,16 +53,49 @@ SYSTEM_PROMPT_UR = """آپ XRayVision AI ہیلتھ اسسٹنٹ ہیں — ای
 اہم قواعد:
 - ہمیشہ یاد دلائیں کہ آپ AI اسسٹنٹ ہیں، حقیقی ڈاکٹر نہیں۔
 - سنگین علامات کے لیے ہمیشہ ہسپتال جانے کی سفارش کریں۔
-- اردو میں جواب دیں۔
+- جواب مختصر رکھیں — زیادہ سے زیادہ 2 سے 4 چھوٹے پیراگراف۔
+
+زبان کے قواعد:
+- ہمیشہ صاف اور آسان اردو میں جواب دیں، ایسی اردو جو ہر عام آدمی سمجھ سکے۔
+- مشکل طبی اصطلاحات استعمال نہ کریں۔ اگر ضروری ہو تو بریکٹ میں آسان لفظوں میں سمجھائیں۔
+- کھانے کی بات کریں تو عام پاکستانی گھریلو چیزیں بتائیں — انڈا، روٹی، ڈبل روٹی، چاول، دال،
+  دہی، کیلا، دودھ، یخنی، چائے — باہر کی یا انجان چیزیں نہ بتائیں۔
+"""
+
+# The markers stay in English so parsing works in both languages; only the
+# values after the colon are translated.
+OUTPUT_FORMAT_EN = """
+At the very end of your reply, on their own separate lines, add exactly:
+DOCTOR_TYPE: <the specialist to see, or the word none>
+HOME_REMEDIES: <simple remedies separated by commas, or the word none>
 """
 
+OUTPUT_FORMAT_UR = """
+اپنے جواب کے بالکل آخر میں، الگ الگ سطروں میں، بالکل یہ لکھیں
+(لیبل انگریزی میں رکھیں، تفصیل اردو میں لکھیں):
+DOCTOR_TYPE: <کس ماہر ڈاکٹر سے ملنا ہے، یا لفظ none>
+HOME_REMEDIES: <آسان گھریلو علاج، کوما سے الگ کر کے، یا لفظ none>
+"""
+
+FALLBACK_REPLY_EN = (
+    "Sorry — I could not reach the AI service just now. "
+    "Please try again in a moment. If your symptoms are severe or getting worse, "
+    "do not wait for this chat: contact a doctor or go to the nearest hospital."
+)
+
+FALLBACK_REPLY_UR = (
+    "معذرت — میں ابھی AI سروس سے رابطہ نہیں کر سکا۔ "
+    "براہ کرم تھوڑی دیر بعد دوبارہ کوشش کریں۔ اگر آپ کی تکلیف شدید ہے یا بڑھ رہی ہے "
+    "تو اس چیٹ کا انتظار نہ کریں — فوراً ڈاکٹر سے رابطہ کریں یا قریبی ہسپتال جائیں۔"
+)
+
 
 def chat_with_health_bot(
     message: str,
     conversation_history: list[dict] | None = None,
     language: str = "en",
 ) -> dict:
-    """Process a health query and return AI response.
+    """Process a health query and return an AI response.
 
     Args:
         message: The user's message.
@@ -59,47 +103,54 @@ def chat_with_health_bot(
         language: "en" for English, "ur" for Urdu.
 
     Returns:
-        Dict with reply, doctor_type, and home_remedies.
+        Dict with reply, doctor_type, home_remedies, and an `ok` flag that is
+        False when the AI service could not be reached.
     """
-    system_prompt = SYSTEM_PROMPT_UR if language == "ur" else SYSTEM_PROMPT_EN
-
-    # Build conversation context
-    messages = [system_prompt]
-
-    if conversation_history:
-        for msg in conversation_history[-10:]:  # Last 10 messages for context
-            role = "User" if msg.get("role") == "user" else "Assistant"
-            messages.append(f"{role}: {msg.get('content', '')}")
+    urdu = language == "ur"
+    system_prompt = SYSTEM_PROMPT_UR if urdu else SYSTEM_PROMPT_EN
+    output_format = OUTPUT_FORMAT_UR if urdu else OUTPUT_FORMAT_EN
 
-    messages.append(f"User: {message}")
+    # Real chat roles instead of one flattened prompt — this is what the model
+    # is trained on, and it keeps the system rules from being ignored.
+    messages: list[dict] = [{"role": "system", "content": system_prompt + output_format}]
 
-    lang_instruction = ""
-    if language == "ur":
-        lang_instruction = "\n\nIMPORTANT: Respond entirely in Urdu (اردو)."
+    for msg in (conversation_history or [])[-10:]:
+        role = "user" if msg.get("role") == "user" else "assistant"
+        content = (msg.get("content") or "").strip()
+        if content:
+            messages.append({"role": role, "content": content})
 
-    full_prompt = "\n\n".join(messages) + lang_instruction + """
+    if urdu:
+        # Repeated next to the user's turn because a long history can otherwise
+        # pull the model back into English.
+        message = f"{message}\n\n(اہم: پورا جواب صرف اردو میں دیں۔)"
 
-Respond with helpful medical guidance. Also include at the end of your response (in a new line):
-DOCTOR_TYPE: <specialist type or "none">
-HOME_REMEDIES: <comma-separated list of remedies or "none">
-"""
+    messages.append({"role": "user", "content": message})
 
     try:
-        response_text = complete_text(full_prompt, temperature=0.35, max_tokens=1200)
-        return _parse_chat_response(response_text)
-    except Exception as e:
-        logger.error(f"Chatbot error: {e}")
+        response_text = complete_chat(messages, temperature=0.35, max_tokens=1200)
+    except OpenRouterError as exc:
+        logger.error("Chatbot unavailable: %s", exc)
         return {
-            "reply": (
-                "I apologize, but I'm currently unable to process your request. "
-                "Please try again later or consult a medical professional directly."
-                if language == "en" else
-                "معذرت، میں ابھی آپ کی درخواست پر عمل نہیں کر سکتا۔ "
-                "براہ کرم بعد میں دوبارہ کوشش کریں یا براہ راست ڈاکٹر سے مشورہ کریں۔"
-            ),
+            "reply": FALLBACK_REPLY_UR if urdu else FALLBACK_REPLY_EN,
             "doctor_type": None,
             "home_remedies": [],
+            "ok": False,
+            "error": exc.user_message,
         }
+    except Exception as exc:  # noqa: BLE001 - never let the chat route 500
+        logger.exception("Unexpected chatbot error: %s", exc)
+        return {
+            "reply": FALLBACK_REPLY_UR if urdu else FALLBACK_REPLY_EN,
+            "doctor_type": None,
+            "home_remedies": [],
+            "ok": False,
+            "error": "The AI service is unavailable right now.",
+        }
+
+    parsed = _parse_chat_response(response_text)
+    parsed["ok"] = True
+    return parsed
 
 
 def _parse_chat_response(text: str) -> dict:
@@ -107,22 +158,30 @@ def _parse_chat_response(text: str) -> dict:
     lines = text.strip().split("\n")
     reply_lines = []
     doctor_type = None
-    home_remedies = []
+    home_remedies: list[str] = []
 
     for line in lines:
-        stripped = line.strip()
-        if stripped.upper().startswith("DOCTOR_TYPE:"):
-            val = stripped.split(":", 1)[1].strip()
-            doctor_type = val if val.lower() != "none" else None
-        elif stripped.upper().startswith("HOME_REMEDIES:"):
-            val = stripped.split(":", 1)[1].strip()
-            if val.lower() != "none":
+        stripped = line.strip().lstrip("*# ").strip()
+        upper = stripped.upper()
+
+        if upper.startswith("DOCTOR_TYPE:"):
+            val = stripped.split(":", 1)[1].strip().strip("*_ ")
+            doctor_type = val if val.lower() not in ("none", "") else None
+        elif upper.startswith("HOME_REMEDIES:"):
+            val = stripped.split(":", 1)[1].strip().strip("*_ ")
+            if val.lower() not in ("none", ""):
                 home_remedies = [r.strip() for r in val.split(",") if r.strip()]
         else:
             reply_lines.append(line)
 
+    reply = "\n".join(reply_lines).strip()
+
+    # If the model emitted nothing but the markers, still show something.
+    if not reply:
+        reply = text.strip()
+
     return {
-        "reply": "\n".join(reply_lines).strip(),
+        "reply": reply,
         "doctor_type": doctor_type,
         "home_remedies": home_remedies,
     }

app/services/diet_service.py

@@ -1,7 +1,11 @@
 """Personalized diet plan generator powered by OpenRouter.
 
-The model creates the menu, while this service adds condition-specific
-guardrails and validates that the response is complete enough to show.
+The plans are written for ordinary households in Pakistan. That constraint is
+the whole point of this module: an earlier version produced things like
+"Protein Salad Bowl" and "Oat Berry Bowl", which most users here do not
+recognise, cannot buy easily, and will not cook. Everything below — the prompt,
+the validation, and the offline fallback — pushes the output towards food people
+actually eat: anda, roti, daal, chawal, sabzi, dahi, kela.
 """
 
 from __future__ import annotations
@@ -10,13 +14,23 @@ import json
 import logging
 import re
 
-from app.services.openrouter_client import complete_text
+from app.services.openrouter_client import OpenRouterError, complete_text
 
 logger = logging.getLogger(__name__)
 
-HYPERTENSION_TERMS = ("hypertension", "high blood pressure", "blood pressure", "bp")
-DIABETES_TERMS = ("diabetes", "diabetic", "blood sugar", "glucose")
-KIDNEY_TERMS = ("kidney", "renal", "ckd", "dialysis")
+HYPERTENSION_TERMS = ("hypertension", "high blood pressure", "blood pressure", "bp", "بلڈ پریشر")
+DIABETES_TERMS = ("diabetes", "diabetic", "blood sugar", "glucose", "sugar", "shugar", "شوگر")
+KIDNEY_TERMS = ("kidney", "renal", "ckd", "dialysis", "گردہ", "گردے")
+
+# Foods the model reaches for by default that do not belong in a plan meant for
+# a Pakistani kitchen. If several show up, the generated plan is rejected.
+UNFAMILIAR_FOODS = (
+    "quinoa", "oat", "oatmeal", "granola", "kale", "avocado", "tofu",
+    "hummus", "chia", "smoothie bowl", "berry bowl", "salad bowl",
+    "cottage cheese", "salmon", "asparagus", "zucchini", "couscous",
+    "tortilla", "bagel", "pancake", "protein shake", "protein bar",
+    "miso", "sushi", "broccoli", "edamame",
+)
 
 
 def generate_diet_plan(
@@ -26,60 +40,97 @@ def generate_diet_plan(
     goals: str = "general health",
     language: str = "en",
 ) -> dict:
-    """Generate a personalized weekly diet plan."""
+    """Generate a simple, personalized 7-day Pakistani meal plan."""
     restrictions = restrictions or []
     condition_text = condition or "general wellness"
     restrictions_text = ", ".join(restrictions) if restrictions else "none"
-    lang_instruction = "Respond entirely in Urdu." if language == "ur" else ""
+    urdu = language == "ur"
+
+    lang_instruction = (
+        "Write every name, description, nutrient and tip in simple Urdu (اردو). "
+        "Use the Urdu words people actually say at home: انڈا، روٹی، دال، چاول، سبزی، دہی، کیلا۔"
+        if urdu
+        else "Write in simple English. Use the local name first and a short English "
+        "explanation in brackets where helpful, e.g. \"Daal Chawal (lentils with rice)\"."
+    )
 
-    prompt = f"""You are a nutrition assistant creating an educational 7-day meal plan.
+    prompt = f"""You are a nutrition assistant creating a simple, educational 7-day meal plan
+for an ordinary household in Pakistan.
 
 PATIENT CONTEXT:
 - Medical Condition: {condition_text}
 - Dietary Preference: {dietary_preferences}
-- Restrictions: {restrictions_text}
-- Health Goals: {goals}
+- Things to avoid: {restrictions_text}
+- Health Goal: {goals}
 
 {lang_instruction}
 
+THE MOST IMPORTANT RULE — KEEP IT SIMPLE AND LOCAL:
+- Only use everyday Pakistani home food that is cheap and available in any local market.
+- Good examples: anda (egg), roti, double roti (bread), chawal (rice), daal (lentils),
+  chana, sabzi (vegetable curry), aloo, palak, bhindi, dahi (yogurt), lassi, doodh (milk),
+  kela (banana), seb (apple), malta, chicken salan, yakhni, khichdi, paratha, halwa,
+  raita, kheera, gajar, tamatar, pyaz, chai.
+- NEVER use foods most Pakistani households would not recognise or buy: no quinoa, no oats
+  or oatmeal, no granola, no kale, no avocado, no tofu, no hummus, no chia seeds, no
+  "protein salad bowl", no "berry bowl", no salmon, no broccoli, no couscous, no smoothies.
+- Name each meal the way a person would say it at home, not like a restaurant menu.
+- Descriptions must be one short, plain sentence a person with no education in nutrition
+  can follow. Say the portion in normal words: "2 roti", "aik pyali chawal", "aik anda".
+- Do not use nutrition jargon. Write "gives energy" or "good for strength", not
+  "macronutrient profile" or "micronutrient density".
+- Vary the 7 days so it is not the same food every day.
+
 MEDICAL AND SAFETY RULES:
 {_condition_rules(condition_text, goals)}
 
-RESTRICTION RULES:
+FOODS TO AVOID FOR THIS PERSON:
 {_restriction_rules(restrictions)}
 
 QUALITY RULES:
 - Include exactly 7 days, Day 1 through Day 7.
-- Use realistic meals and portions, not extreme dieting.
+- Use realistic home portions, not extreme dieting.
 - Calorie values must be plausible estimates per meal.
-- Do not include foods that violate allergies or restrictions.
-- Tips must include one professional-safety note when a medical condition is present.
-- Do not claim the plan diagnoses, treats, cures, or replaces clinician care.
+- Give 3 to 5 short tips in plain language.
+- Do not claim the plan diagnoses, treats, cures, or replaces a doctor.
 
-Respond ONLY in this JSON format, with no markdown or extra text:
+Respond ONLY in this JSON format, with no markdown and no extra text:
 {{
-  "title": "<diet plan title>",
-  "summary": "<2-3 sentence summary of the diet approach>",
+  "title": "<short plan title>",
+  "summary": "<2-3 simple sentences about the plan>",
   "plan": [
     {{
       "day": "Day 1",
-      "breakfast": {{"name": "<meal>", "description": "<brief description>", "calories": <number>, "nutrients": "<key nutrients>"}},
-      "lunch": {{"name": "<meal>", "description": "<brief description>", "calories": <number>, "nutrients": "<key nutrients>"}},
-      "dinner": {{"name": "<meal>", "description": "<brief description>", "calories": <number>, "nutrients": "<key nutrients>"}},
-      "snacks": [{{"name": "<snack>", "description": "<brief>", "calories": <number>, "nutrients": "<key nutrients>"}}]
+      "breakfast": {{"name": "<meal>", "description": "<one plain sentence>", "calories": <number>, "nutrients": "<simple benefit, e.g. protein and energy>"}},
+      "lunch": {{"name": "<meal>", "description": "<one plain sentence>", "calories": <number>, "nutrients": "<simple benefit>"}},
+      "dinner": {{"name": "<meal>", "description": "<one plain sentence>", "calories": <number>, "nutrients": "<simple benefit>"}},
+      "snacks": [{{"name": "<snack>", "description": "<one plain sentence>", "calories": <number>, "nutrients": "<simple benefit>"}}]
     }}
   ],
-  "tips": ["<health tip 1>", "<health tip 2>", "<health tip 3>"]
+  "tips": ["<simple tip 1>", "<simple tip 2>", "<simple tip 3>"]
 }}
 """
 
     try:
-        response_text = complete_text(prompt, temperature=0.25, max_tokens=2600)
+        # A 7-day plan is ~2,500 tokens of JSON on its own. The free tier
+        # routes to reasoning models that spend most of a small budget
+        # thinking, so give it real headroom and turn the thinking down.
+        response_text = complete_text(
+            prompt,
+            temperature=0.35,
+            max_tokens=16000,
+            reasoning={"effort": "low", "exclude": True},
+        )
         parsed = _parse_diet_response(response_text)
-        return _normalize_diet_plan(parsed, condition_text, dietary_preferences, restrictions, goals)
-    except Exception as exc:
-        logger.error("Diet plan generation failed: %s", exc)
-        return _fallback_diet_plan(condition_text, dietary_preferences, restrictions, goals)
+        return _normalize_diet_plan(
+            parsed, condition_text, dietary_preferences, restrictions, goals, language
+        )
+    except OpenRouterError as exc:
+        logger.error("Diet plan generation unavailable: %s", exc)
+        return _fallback_diet_plan(condition_text, dietary_preferences, restrictions, goals, language)
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("Diet plan generation failed: %s", exc)
+        return _fallback_diet_plan(condition_text, dietary_preferences, restrictions, goals, language)
 
 
 def _has_any(text: str, terms: tuple[str, ...]) -> bool:
@@ -90,28 +141,35 @@ def _has_any(text: str, terms: tuple[str, ...]) -> bool:
 def _condition_rules(condition: str, goals: str) -> str:
     context = f"{condition} {goals}".lower()
     rules = [
-        "Use whole foods, realistic portions, and culturally adaptable meals.",
-        "Avoid claiming the plan treats, cures, or replaces care from a clinician.",
-        "Do not include foods that conflict with stated allergies or restrictions.",
-        "Include calorie estimates, but avoid extreme daily calorie restriction.",
+        "Use simple home-cooked food and normal portions.",
+        "Do not claim the plan treats or cures anything, or replaces a doctor.",
+        "Do not include any food the person said they must avoid.",
+        "Include calorie estimates, but never suggest starving or skipping meals.",
     ]
 
     if _has_any(context, HYPERTENSION_TERMS):
         rules.extend([
-            "For blood pressure, follow a DASH-style pattern: vegetables, fruits, beans/lentils, whole grains, fish/poultry/soy, nuts/seeds, and unsaturated fats.",
-            "Keep sodium low: prefer unsalted/no-salt-added foods; avoid processed meats, instant noodles, pickles, salty sauces, regular miso, regular soy sauce, and salty packaged snacks.",
-            "Mention a sodium target of no more than 2,300 mg/day, and ideally 1,500 mg/day if advised by a clinician.",
-            "Emphasize potassium-rich foods only with a caution: people with kidney disease or potassium-raising medicines should ask a clinician first.",
+            "For high blood pressure, keep salt low: say clearly to use less namak while cooking,"
+            " and to avoid achaar (pickle), papad, chips, packet noodles, and salty snacks.",
+            "Prefer fresh sabzi, daal, chana, fruit, and plain dahi.",
+            "Mention keeping salt under about one small teaspoon a day, and less if the doctor says so.",
+            "Only suggest potassium-rich foods with a caution: anyone with kidney trouble or on"
+            " blood pressure medicines should ask their doctor first.",
         ])
     if _has_any(context, DIABETES_TERMS):
         rules.extend([
-            "For diabetes, distribute carbohydrates across meals and pair carbs with protein, fiber, or healthy fat.",
-            "Avoid sugary drinks and large dessert portions; prefer low-glycemic whole grains, legumes, non-starchy vegetables, lean proteins, and unsweetened foods.",
+            "For sugar (diabetes), spread roti and rice through the day instead of one big meal,"
+            " and always pair them with daal, sabzi, anda, dahi or meat.",
+            "Say clearly to avoid soft drinks, packet juice, mithai, and lots of sugar in chai.",
+            "Prefer chapati over white bread, and a smaller portion of rice.",
+            "NEVER put these in a diabetic plan, not even once: halwa puri, puri, jalebi, gulab jamun,"
+            " mithai, sheer khurma, sweet lassi, rooh afza, sugary paratha, cake, biscuits, or any"
+            " deep-fried nashta. They are normal Pakistani foods but they are wrong for this person.",
         ])
     if _has_any(context, KIDNEY_TERMS):
         rules.extend([
-            "For kidney disease, do not recommend high-potassium or high-phosphorus patterns unless clinician-approved.",
-            "Avoid generic advice to increase potassium; recommend renal dietitian review.",
+            "For kidney problems, do not push high-potassium or high-phosphorus food unless a doctor approves.",
+            "Say clearly that a kidney patient must get the plan checked by their own doctor or dietitian.",
         ])
 
     return "\n".join(f"- {rule}" for rule in rules)
@@ -121,97 +179,421 @@ def _restriction_rules(restrictions: list[str]) -> str:
     joined = " ".join(restrictions).lower()
     rules: list[str] = []
 
-    if "dairy" in joined or "lactose" in joined:
-        rules.append("Dairy-free means no milk, yogurt, cheese, paneer, butter, cream, whey, casein, or cottage cheese; use fortified unsweetened alternatives if needed.")
-    if "gluten" in joined:
-        rules.append("Gluten-free means no wheat, barley, rye, regular bread, regular pasta, or standard wraps; use certified gluten-free grains.")
-    if "nut" in joined or "peanut" in joined:
-        rules.append("Nut allergy means no tree nuts, peanuts, nut butters, almond milk, cashews, walnuts, pistachios, or nut-based snacks.")
-    if "shellfish" in joined or "shrimp" in joined:
-        rules.append("Shellfish restriction means no shrimp, prawns, crab, lobster, or shellfish sauces.")
-
-    return "\n".join(f"- {rule}" for rule in rules) or "- No extra restriction-specific exclusions."
+    if "dairy" in joined or "lactose" in joined or "milk" in joined:
+        rules.append(
+            "No dairy: no doodh, dahi, lassi, paneer, makhan, cream, or cheese."
+        )
+    if "gluten" in joined or "wheat" in joined:
+        rules.append(
+            "No gluten: no wheat roti, no double roti, no naan, no suji. Use rice, chawal ki roti,"
+            " besan (gram flour) or makai (corn) roti instead."
+        )
+    if "nut" in joined or "peanut" in joined or "badam" in joined:
+        rules.append("No nuts: no badam, akhrot, moongphali, pista, kaju, or nut-based food.")
+    if "egg" in joined or "anda" in joined:
+        rules.append("No eggs: do not use anda in any meal.")
+    if "beef" in joined:
+        rules.append("No beef: use chicken, mutton, fish, daal, or chana instead.")
+    if "vegetarian" in joined or "no meat" in joined:
+        rules.append("Vegetarian: no chicken, mutton, beef, or fish. Use daal, chana, sabzi, dahi and anda.")
+
+    return "\n".join(f"- {rule}" for rule in rules) or "- No extra foods to avoid."
+
+
+def _repair_truncated_plan(text: str) -> dict | None:
+    """Rebuild a plan from output that was cut off mid-JSON.
+
+    Free-tier reasoning models regularly hit the token ceiling partway through
+    day 4 or 5. Everything before the cut is still valid, so the complete day
+    objects are recovered and the caller decides whether enough survived.
+    """
+    if '"plan"' not in text:
+        return None
+
+    def _grab(field: str) -> str:
+        m = re.search(rf'"{field}"\s*:\s*"((?:[^"\\]|\\.)*)"', text)
+        return m.group(1) if m else ""
+
+    start = text.find("[", text.find('"plan"'))
+    if start == -1:
+        return None
+
+    days, depth, obj_start = [], 0, None
+    in_string, escaped = False, False
+
+    for i in range(start, len(text)):
+        ch = text[i]
+        if escaped:
+            escaped = False
+            continue
+        if ch == "\\":
+            escaped = True
+            continue
+        if ch == '"':
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+        if ch == "{":
+            if depth == 0:
+                obj_start = i
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0 and obj_start is not None:
+                try:
+                    days.append(json.loads(text[obj_start:i + 1]))
+                except json.JSONDecodeError:
+                    pass
+                obj_start = None
+        elif ch == "]" and depth == 0:
+            break
+
+    if not days:
+        return None
+
+    logger.warning("Recovered %s day(s) from a truncated diet plan", len(days))
+    return {
+        "title": _grab("title") or "Your Diet Plan",
+        "summary": _grab("summary"),
+        "plan": days,
+        "tips": [],
+    }
 
 
 def _parse_diet_response(text: str) -> dict:
-    """Parse the model response into structured diet plan."""
+    """Parse the model response into a structured diet plan."""
     cleaned = text.strip()
+
+    # Strip markdown fences the model adds despite being told not to.
     if cleaned.startswith("```"):
         lines = cleaned.split("\n")
         cleaned = "\n".join(lines[1:-1] if lines[-1].strip() == "```" else lines[1:]).strip()
 
+    parsed = None
     try:
         parsed = json.loads(cleaned)
     except json.JSONDecodeError:
+        # Fall back to the outermost JSON object in the text.
+        match = re.search(r"\{.*\}", cleaned, re.DOTALL)
+        if match:
+            try:
+                parsed = json.loads(match.group(0))
+            except json.JSONDecodeError:
+                parsed = None
+
+    if parsed is None:
+        # The answer may simply have run out of tokens mid-object. Salvage the
+        # days that did come through rather than throwing the whole plan away.
+        parsed = _repair_truncated_plan(cleaned)
+
+    if parsed is None:
         logger.warning("Failed to parse diet plan JSON")
         return {}
 
+    if not isinstance(parsed, dict):
+        return {}
+
     return {
-        "title": parsed.get("title", "Your Personalized Diet Plan"),
+        "title": parsed.get("title", "Your Diet Plan"),
         "summary": parsed.get("summary", ""),
         "plan": parsed.get("plan", []),
         "tips": parsed.get("tips", []),
     }
 
 
+# Foods that are perfectly normal in a Pakistani kitchen but are wrong for a
+# specific condition. The model does reach for these — a live run put
+# "Halwa puri aur chai" in a diabetes plan — so the prompt rule is backed by a
+# hard check here. Matched on word boundaries so "puri" does not fire inside
+# an unrelated word.
+DIABETES_BANNED = (
+    "halwa puri", "puri", "jalebi", "gulab jamun", "mithai", "sheer khurma",
+    "sweet lassi", "rooh afza", "kheer", "cake", "biscuit", "soft drink",
+    "حلوہ پوری", "پوری", "جلیبی", "مٹھائی", "گلاب جامن", "کھیر", "میٹھی لسی",
+)
+
+HYPERTENSION_BANNED = (
+    "achaar", "achar", "pickle", "papad", "chips", "instant noodles",
+    "processed meat", "salted", "namkeen",
+    "اچار", "پاپڑ", "چپس", "نمکین",
+)
+
+
+# What each restriction actually rules out, in both the Roman-Urdu and Urdu
+# spellings the models produce. A stated restriction may be an allergy, so a
+# single violation rejects the plan — unlike the "unfamiliar food" check,
+# which tolerates a stray mention.
+RESTRICTION_FOODS: dict[str, tuple[str, ...]] = {
+    "egg": ("egg", "eggs", "anda", "ande", "omelette", "omelet", "bhurji",
+            "انڈا", "انڈے", "آملیٹ", "بھجیا"),
+    "dairy": ("milk", "yogurt", "yoghurt", "curd", "dahi", "paneer", "cheese",
+              "butter", "cream", "lassi", "raita", "karhi", "kheer", "doodh",
+              "دودھ", "دہی", "پنیر", "مکھن", "کریم", "لسی", "رائتہ", "رائتے",
+              "کڑھی", "کھیر"),
+    "gluten": ("wheat", "roti", "chapati", "chapatti", "naan", "paratha",
+               "bread", "suji", "semolina", "maida", "dalia",
+               "گندم", "روٹی", "چپاتی", "نان", "پراٹھا", "سوجی", "میدہ"),
+    "nuts": ("almond", "badam", "walnut", "akhrot", "peanut", "moongphali",
+             "cashew", "kaju", "pista", "pistachio",
+             "بادام", "اخروٹ", "مونگ پھلی", "کاجو", "پستہ"),
+}
+
+# Dishes that are gluten-free despite containing a word from the list above:
+# corn/rice/gram-flour breads, and dalia made from rice rather than wheat.
+GLUTEN_SAFE_PHRASES = (
+    "makai ki roti", "chawal ki roti", "besan ki roti", "corn roti",
+    "chawal ka dalia", "rice porridge",
+    "مکئی کی روٹی", "چاول کی روٹی", "بیسن کی روٹی", "چاول کا دلیہ",
+)
+
+RESTRICTION_ALIASES = {
+    "egg": "egg", "anda": "egg", "انڈا": "egg",
+    "dairy": "dairy", "lactose": "dairy", "milk": "dairy", "دودھ": "dairy",
+    "gluten": "gluten", "wheat": "gluten", "roti": "gluten", "گندم": "gluten",
+    "nut": "nuts", "nuts": "nuts", "peanut": "nuts", "badam": "nuts", "بادام": "nuts",
+}
+
+
+def _violates_restrictions(days: list, restrictions: list[str]) -> list[str]:
+    """Foods in the plan that the user said they cannot eat."""
+    if not restrictions:
+        return []
+
+    keys = set()
+    joined = " ".join(restrictions).lower()
+    for alias, key in RESTRICTION_ALIASES.items():
+        if alias in joined:
+            keys.add(key)
+    if not keys:
+        return []
+
+    found: list[str] = []
+    for text in _meal_texts(days):
+        cleaned = text
+        for safe in GLUTEN_SAFE_PHRASES:
+            cleaned = cleaned.replace(safe, " ")
+        for key in keys:
+            for food in RESTRICTION_FOODS[key]:
+                if re.search(rf"(?<!\w){re.escape(food)}(?!\w)", cleaned):
+                    found.append(f"{key}:{food}")
+    return found
+
+
+def _meal_texts(days: list) -> list[str]:
+    """Every meal name + description in the plan, lowercased."""
+    texts = []
+    for day in days:
+        if not isinstance(day, dict):
+            continue
+        meals = [day.get("breakfast"), day.get("lunch"), day.get("dinner")]
+        meals += day.get("snacks") if isinstance(day.get("snacks"), list) else []
+        for meal in meals:
+            if isinstance(meal, dict):
+                texts.append(f"{meal.get('name', '')} {meal.get('description', '')}".lower())
+    return texts
+
+
+def _unsafe_for_condition(days: list, condition: str, goals: str) -> list[str]:
+    """Foods in the plan that are unsafe for the stated condition."""
+    context = f"{condition} {goals}"
+    banned: tuple[str, ...] = ()
+    if _has_any(context, DIABETES_TERMS):
+        banned += DIABETES_BANNED
+    if _has_any(context, HYPERTENSION_TERMS):
+        banned += HYPERTENSION_BANNED
+    if not banned:
+        return []
+
+    found = []
+    for text in _meal_texts(days):
+        for item in banned:
+            if re.search(rf"(?<!\w){re.escape(item)}(?!\w)", text):
+                found.append(item)
+    return found
+
+
+def _counts_unfamiliar_foods(days: list) -> int:
+    """How many meals mention food a Pakistani household would not recognise."""
+    hits = 0
+    for day in days:
+        if not isinstance(day, dict):
+            continue
+        meals = [day.get("breakfast"), day.get("lunch"), day.get("dinner")]
+        meals += day.get("snacks") if isinstance(day.get("snacks"), list) else []
+        for meal in meals:
+            if not isinstance(meal, dict):
+                continue
+            text = f"{meal.get('name', '')} {meal.get('description', '')}".lower()
+            if any(food in text for food in UNFAMILIAR_FOODS):
+                hits += 1
+    return hits
+
+
+URDU_DAY_NAMES = (
+    "پہلا دن", "دوسرا دن", "تیسرا دن", "چوتھا دن",
+    "پانچواں دن", "چھٹا دن", "ساتواں دن",
+)
+
+
+def _day_label(index: int, language: str) -> str:
+    """Human day name for position `index` (1-based)."""
+    if language == "ur" and 1 <= index <= len(URDU_DAY_NAMES):
+        return URDU_DAY_NAMES[index - 1]
+    return f"Day {index}"
+
+
+def _top_up_days(days: list, language: str) -> list:
+    """Extend a short plan to 7 days by cycling the days that came through.
+
+    Repeating meals across a week is normal in a real household plan, and the
+    user keeps the food that was chosen for them rather than being handed the
+    generic week instead.
+    """
+    filled = [dict(d) for d in days if isinstance(d, dict)]
+    if not filled:
+        return days
+
+    while len(filled) < 7:
+        filled.append(dict(filled[len(filled) % len(days)]))
+
+    for i, day in enumerate(filled, start=1):
+        day["day"] = _day_label(i, language)
+    return filled
+
+
 def _normalize_diet_plan(
     plan: dict,
     condition: str = "general wellness",
     dietary_preferences: str = "balanced",
     restrictions: list[str] | None = None,
     goals: str = "general health",
+    language: str = "en",
 ) -> dict:
-    """Keep generated plans complete and add condition-specific guardrails."""
+    """Keep generated plans complete, local, and safe."""
     restrictions = restrictions or []
     days = plan.get("plan") if isinstance(plan.get("plan"), list) else []
+
+    # A plan cut short at day 6 is still the user's own personalized plan.
+    # Topping it up beats throwing it away for the generic one; only a badly
+    # short answer falls all the way back.
+    if 5 <= len(days) < 7:
+        logger.info("Diet plan had %s days; topping up to 7", len(days))
+        days = _top_up_days(days, language)
+
     if len(days) != 7:
         logger.warning("Diet plan had %s days; using validated fallback", len(days))
-        return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals)
+        return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals, language)
 
     for idx, day in enumerate(days[:7], start=1):
         if not isinstance(day, dict):
-            return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals)
+            return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals, language)
         day["day"] = day.get("day") or f"Day {idx}"
         for meal_name in ("breakfast", "lunch", "dinner"):
             meal = day.get(meal_name)
             if not isinstance(meal, dict) or not meal.get("name"):
                 logger.warning("Diet plan missing %s on day %s; using fallback", meal_name, idx)
-                return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals)
+                return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals, language)
         if not isinstance(day.get("snacks"), list):
             day["snacks"] = []
 
+    # The client's actual complaint: plans full of food nobody here eats.
+    # A stray mention is tolerable; a plan built on them is not.
+    unfamiliar = _counts_unfamiliar_foods(days)
+    if unfamiliar >= 4:
+        logger.warning(
+            "Diet plan used %s unfamiliar foods; falling back to the local plan", unfamiliar
+        )
+        return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals, language)
+
+    # Safety, not taste: one mithai or halwa puri in a diabetic plan is enough
+    # to reject the whole thing.
+    unsafe = _unsafe_for_condition(days, condition, goals)
+    if unsafe:
+        logger.warning(
+            "Diet plan contained food unsafe for '%s' (%s); using the validated fallback",
+            condition, ", ".join(sorted(set(unsafe))[:5]),
+        )
+        return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals, language)
+
+    # A stated restriction may be an allergy. The model does ignore these —
+    # a live run returned anda to someone who had excluded egg — so one
+    # violation is enough to reject the plan.
+    violations = _violates_restrictions(days, restrictions)
+    if violations:
+        logger.warning(
+            "Diet plan broke a stated restriction (%s); using the validated fallback",
+            ", ".join(sorted(set(violations))[:5]),
+        )
+        return _fallback_diet_plan(condition, dietary_preferences, restrictions, goals, language)
+
     tips = [str(t) for t in plan.get("tips", []) if str(t).strip()]
     context = f"{condition} {goals}"
+    urdu = language == "ur"
 
     if _has_any(context, HYPERTENSION_TERMS):
-        tips = _merge_tips(tips, [
-            "Keep sodium under 2,300 mg/day; ask a clinician whether a 1,500 mg/day target is appropriate.",
-            "Use potassium-rich foods for blood pressure only if you do not have kidney disease and are not on potassium-raising medicines.",
-            "Choose no-salt-added foods and herbs/spices instead of salty sauces or packaged snacks.",
-        ])
+        tips = _merge_tips(tips, _BP_TIPS_UR if urdu else _BP_TIPS_EN)
     if _has_any(context, DIABETES_TERMS):
-        tips = _merge_tips(tips, [
-            "Monitor blood glucose response and coordinate meal timing with prescribed diabetes medicines.",
-            "Pair carbohydrate foods with protein, fiber, and healthy fats to reduce glucose spikes.",
-        ])
+        tips = _merge_tips(tips, _SUGAR_TIPS_UR if urdu else _SUGAR_TIPS_EN)
     if _has_any(context, KIDNEY_TERMS):
-        tips = _merge_tips(tips, [
-            "Kidney disease diets must be individualized for potassium, phosphorus, sodium, protein, and fluid limits.",
-            "Review this plan with a renal dietitian or clinician before following it.",
-        ])
+        tips = _merge_tips(tips, _KIDNEY_TIPS_UR if urdu else _KIDNEY_TIPS_EN)
     if condition and condition.lower() != "general wellness":
-        tips = _merge_tips(tips, [
-            "This educational plan should be reviewed by a qualified clinician or dietitian for your diagnosis, medicines, labs, and allergies.",
-        ])
+        tips = _merge_tips(tips, [_DOCTOR_TIP_UR if urdu else _DOCTOR_TIP_EN])
+
+    default_title = "آپ کا کھانے کا پلان" if urdu else "Your 7-Day Meal Plan"
+    default_summary = (
+        "سات دن کا آسان پلان، روزمرہ کے پاکستانی گھریلو کھانوں پر مبنی۔"
+        if urdu
+        else "A simple 7-day plan built from everyday Pakistani home food."
+    )
 
     return {
-        "title": plan.get("title") or "Your Personalized Diet Plan",
-        "summary": plan.get("summary") or "A structured 7-day meal plan built around whole foods, balanced portions, and the stated health goals.",
+        "title": plan.get("title") or default_title,
+        "summary": plan.get("summary") or default_summary,
         "plan": days[:7],
         "tips": tips[:6],
     }
 
 
+_DOCTOR_TIP_EN = (
+    "Show this plan to your doctor or a dietitian before following it, "
+    "especially if you take any medicine."
+)
+_DOCTOR_TIP_UR = (
+    "اس پلان پر عمل کرنے سے پہلے اسے اپنے ڈاکٹر یا ماہرِ غذا کو ضرور دکھائیں، "
+    "خاص طور پر اگر آپ کوئی دوا لے رہے ہیں۔"
+)
+
+_BP_TIPS_EN = [
+    "Use less namak (salt) while cooking, and do not add extra salt at the table.",
+    "Avoid achaar, papad, chips, packet noodles and other salty snacks.",
+    "If you have any kidney problem or take blood pressure medicine, ask your doctor before eating a lot of fruit.",
+]
+_BP_TIPS_UR = [
+    "کھانا پکاتے وقت نمک کم استعمال کریں، اور اوپر سے مزید نمک نہ ڈالیں۔",
+    "اچار، پاپڑ، چپس، پیکٹ والے نوڈلز اور نمکین اسنیکس سے پرہیز کریں۔",
+    "اگر گردے کی تکلیف ہے یا بلڈ پریشر کی دوا لیتے ہیں تو زیادہ پھل کھانے سے پہلے ڈاکٹر سے پوچھیں۔",
+]
+
+_SUGAR_TIPS_EN = [
+    "Avoid soft drinks, packet juice and mithai. Take chai with little or no sugar.",
+    "Eat roti or rice together with daal, sabzi, anda or dahi — not on their own.",
+]
+_SUGAR_TIPS_UR = [
+    "کولڈ ڈرنک، پیکٹ والا جوس اور مٹھائی نہ لیں۔ چائے میں چینی بہت کم یا بالکل نہ ڈالیں۔",
+    "روٹی یا چاول ہمیشہ دال، سبزی، انڈے یا دہی کے ساتھ کھائیں، اکیلے نہیں۔",
+]
+
+_KIDNEY_TIPS_EN = [
+    "A kidney patient's diet must be set by their own doctor — salt, potassium, protein and water all change.",
+    "Do not increase fruit, daal or milk on your own if you have kidney disease.",
+]
+_KIDNEY_TIPS_UR = [
+    "گردے کے مریض کی خوراک اُس کا اپنا ڈاکٹر طے کرے — نمک، پوٹاشیم، پروٹین اور پانی سب بدلتے ہیں۔",
+    "گردے کی بیماری میں پھل، دال یا دودھ اپنی مرضی سے نہ بڑھائیں۔",
+]
+
+
 def _merge_tips(existing: list[str], required: list[str]) -> list[str]:
     merged = list(existing)
     comparable = " ".join(_tip_key(tip) for tip in existing)
@@ -222,109 +604,326 @@ def _merge_tips(existing: list[str], required: list[str]) -> list[str]:
 
 
 def _tip_key(tip: str) -> str:
-    words = re.sub(r"[^a-z0-9]+", " ", tip.lower()).strip().split()
+    words = re.sub(r"[^a-z0-9؀-ۿ]+", " ", tip.lower()).strip().split()
     return " ".join(words[:5])
 
 
+# ── Offline fallback: a plain Pakistani week ──────────────────────────────
+#
+# Used when OpenRouter is unreachable or returns something unusable. It is the
+# plan the client will actually see on a bad day, so it is written to the same
+# standard as the prompt above: real home food, real portions, plain words.
+
+def _meal(name: str, description: str, calories: int, nutrients: str) -> dict:
+    return {
+        "name": name,
+        "description": description,
+        "calories": calories,
+        "nutrients": nutrients,
+    }
+
+
+def _base_week_en(
+    vegetarian: bool, dairy_free: bool, no_egg: bool, gluten_free: bool = False
+) -> list[dict]:
+    # Makai (corn) roti is the everyday gluten-free bread here — far more
+    # familiar to this audience than any imported substitute.
+    roti = "Makai ki Roti" if gluten_free else "Roti"
+    roti_low = "makai ki roti" if gluten_free else "roti"
+    paratha = "Makai ki Roti" if gluten_free else "Paratha"
+    paratha_low = "makai ki roti" if gluten_free else "paratha"
+    bread = "Chawal" if gluten_free else "Double Roti"
+    bread_desc = "a small bowl of rice" if gluten_free else "two slices of bread"
+    dalia_name = "Chawal ka Dalia" if gluten_free else "Suji Dalia"
+    dalia_grain = "rice porridge" if gluten_free else "wheat porridge"
+
+    egg_breakfast = (
+        _meal(f"Aloo {paratha} aur Chai", f"One {paratha_low} with a cup of tea.", 420, "Energy")
+        if no_egg
+        else _meal(f"Anda aur {roti}", f"Two eggs with one {roti_low} and a cup of tea.", 400, "Protein and energy")
+    )
+    dahi_item = (
+        _meal("Kela (banana)", "One banana.", 100, "Energy and potassium")
+        if dairy_free
+        else _meal("Dahi (yogurt)", "One small bowl of plain yogurt.", 100, "Protein and good for the stomach")
+    )
+    meat_lunch = (
+        _meal("Chana Chaat", f"Boiled chickpeas with onion, tomato and lemon, with one {roti_low}.", 480, "Protein and fibre")
+        if vegetarian
+        else _meal(f"Chicken Salan aur {roti}", f"Chicken curry with two {roti_low} and a slice of onion and cucumber.", 550, "Protein and energy")
+    )
+    meat_dinner = (
+        _meal("Daal aur Chawal", "Lentils with one bowl of rice.", 480, "Protein and energy")
+        if vegetarian
+        else _meal(f"Chicken Yakhni aur {roti}", f"Light chicken soup with one {roti_low}.", 420, "Protein, easy to digest")
+    )
+    # Dalia is normally cooked in milk and biryani is normally served with
+    # raita — both have to drop the dairy when the user cannot have it.
+    dalia_liquid = "water" if dairy_free else "water or milk"
+    biryani_side = "salad" if dairy_free else "raita or salad"
+
+    return [
+        {
+            "day": "Day 1",
+            "breakfast": egg_breakfast,
+            "lunch": _meal("Daal Chawal", "Lentils with one bowl of rice and a plain salad.", 500, "Protein and energy"),
+            "dinner": _meal(f"Mix Sabzi aur {roti}", f"Mixed vegetable curry with two {roti_low}.", 450, "Vitamins and fibre"),
+            "snacks": [dahi_item],
+        },
+        {
+            "day": "Day 2",
+            "breakfast": _meal(
+                f"{bread} aur Anda" if not no_egg else f"{bread} aur Jam",
+                f"An omelette with {bread_desc} and tea." if not no_egg else f"Jam with {bread_desc} and tea.",
+                380,
+                "Protein and energy" if not no_egg else "Energy",
+            ),
+            "lunch": meat_lunch,
+            "dinner": _meal("Khichdi", "Soft rice and lentils cooked together, with a little plain salad.", 430, "Light and easy to digest"),
+            "snacks": [_meal("Seb (apple)", "One apple.", 90, "Fibre and vitamins")],
+        },
+        {
+            "day": "Day 3",
+            "breakfast": _meal(dalia_name, f"A bowl of {dalia_grain} cooked in {dalia_liquid}, with a banana.", 350, "Energy and fibre"),
+            "lunch": _meal(f"Aloo Gosht aur {roti}" if not vegetarian else f"Aloo Palak aur {roti}",
+                           f"Potato curry with meat and two {roti_low}." if not vegetarian else f"Potato and spinach curry with two {roti_low}.",
+                           520, "Protein and iron"),
+            "dinner": _meal(f"Bhindi aur {roti}", f"Okra curry with two {roti_low}.", 420, "Fibre and vitamins"),
+            "snacks": [_meal("Malta ya Kela", "One orange or one banana.", 90, "Vitamin C")],
+        },
+        {
+            "day": "Day 4",
+            "breakfast": _meal(
+                f"Anda Bhurji aur {roti}" if not no_egg else "Chana Chaat Nashta",
+                f"Scrambled eggs with one {roti_low} and tea." if not no_egg else "A small bowl of boiled chickpeas with lemon and tea.",
+                400,
+                "Protein",
+            ),
+            "lunch": _meal(f"Chana Daal aur {roti}", f"Split chickpea lentils with two {roti_low} and salad.", 490, "Protein and fibre"),
+            "dinner": _meal("Vegetable Pulao", "Rice cooked with peas, carrot and potato.", 470, "Energy and vitamins"),
+            "snacks": [dahi_item],
+        },
+        {
+            "day": "Day 5",
+            "breakfast": _meal(f"{paratha} aur Dahi" if not dairy_free else f"{paratha} aur Chai",
+                               f"One {paratha_low} with a small bowl of yogurt." if not dairy_free else f"One {paratha_low} with a cup of tea.",
+                               430, "Energy"),
+            "lunch": meat_dinner if vegetarian else _meal(f"Machli aur {roti}", f"Fried or baked fish with two {roti_low} and salad.", 520, "Protein and good fats"),
+            "dinner": _meal(f"Palak aur {roti}", f"Spinach curry with two {roti_low}.", 400, "Iron and fibre"),
+            "snacks": [_meal("Gajar ya Kheera", "A few carrot or cucumber sticks.", 60, "Fibre and water")],
+        },
+        {
+            "day": "Day 6",
+            "breakfast": _meal(f"Doodh aur {bread}" if not dairy_free else f"Chai aur {bread}",
+                               f"A glass of milk with {bread_desc}." if not dairy_free else f"A cup of tea with {bread_desc}.",
+                               350, "Calcium and energy" if not dairy_free else "Energy"),
+            "lunch": _meal("Rajma ya Lobia Chawal", "Kidney beans or black-eyed peas with one bowl of rice.", 520, "Protein and fibre"),
+            "dinner": _meal("Karhi Chawal" if not dairy_free else f"Daal aur {roti}",
+                            "Yogurt curry with one bowl of rice." if not dairy_free else f"Lentils with two {roti_low}.",
+                            460, "Protein and energy"),
+            "snacks": [_meal("Kela (banana)", "One banana.", 100, "Energy")],
+        },
+        {
+            "day": "Day 7",
+            "breakfast": egg_breakfast,
+            "lunch": _meal("Biryani (small plate)" if not vegetarian else "Sabzi Biryani (small plate)",
+                           f"One small plate of biryani with {biryani_side}.", 600, "Energy and protein"),
+            "dinner": _meal(f"Daal aur {roti}", f"Lentils with two {roti_low} and a plain salad.", 420, "Protein and fibre"),
+            "snacks": [_meal("Mausami Phal", "Any seasonal fruit.", 90, "Vitamins")],
+        },
+    ]
+
+
+def _base_week_ur(
+    vegetarian: bool, dairy_free: bool, no_egg: bool, gluten_free: bool = False
+) -> list[dict]:
+    roti = "مکئی کی روٹی" if gluten_free else "روٹی"
+    paratha = "مکئی کی روٹی" if gluten_free else "پراٹھا"
+    bread = "چاول" if gluten_free else "ڈبل روٹی"
+    bread_desc = "ایک چھوٹی پیالی چاول" if gluten_free else "ڈبل روٹی کے دو سلائس"
+    dalia_name = "چاول کا دلیہ" if gluten_free else "سوجی کا دلیہ"
+
+    egg_breakfast = (
+        _meal(f"آلو {paratha} اور چائے", f"ایک {paratha} اور ایک کپ چائے۔", 420, "توانائی")
+        if no_egg
+        else _meal(f"انڈا اور {roti}", f"دو انڈے، ایک {roti} اور ایک کپ چائے۔", 400, "پروٹین اور توانائی")
+    )
+    dahi_item = (
+        _meal("کیلا", "ایک کیلا۔", 100, "توانائی")
+        if dairy_free
+        else _meal("دہی", "ایک چھوٹی پیالی سادہ دہی۔", 100, "پروٹین، معدے کے لیے اچھا")
+    )
+    meat_lunch = (
+        _meal("چنا چاٹ", f"ابلے ہوئے چنے پیاز، ٹماٹر اور لیموں کے ساتھ، ایک {roti}۔", 480, "پروٹین اور فائبر")
+        if vegetarian
+        else _meal(f"چکن سالن اور {roti}", f"چکن سالن، دو {roti} اور تھوڑا سا سلاد۔", 550, "پروٹین اور توانائی")
+    )
+    meat_dinner = (
+        _meal("دال اور چاول", "دال کے ساتھ ایک پیالی چاول۔", 480, "پروٹین اور توانائی")
+        if vegetarian
+        else _meal(f"چکن یخنی اور {roti}", f"ہلکی چکن یخنی اور ایک {roti}۔", 420, "پروٹین، آسانی سے ہضم")
+    )
+    dalia_liquid = "پانی" if dairy_free else "پانی یا دودھ"
+    biryani_side = "سلاد" if dairy_free else "رائتے یا سلاد"
+
+    return [
+        {
+            "day": "پہلا دن",
+            "breakfast": egg_breakfast,
+            "lunch": _meal("دال چاول", "دال کے ساتھ ایک پیالی چاول اور سادہ سلاد۔", 500, "پروٹین اور توانائی"),
+            "dinner": _meal(f"مکس سبزی اور {roti}", f"ملی جلی سبزی کے ساتھ دو {roti}۔", 450, "وٹامن اور فائبر"),
+            "snacks": [dahi_item],
+        },
+        {
+            "day": "دوسرا دن",
+            "breakfast": _meal(
+                f"{bread} اور انڈا" if not no_egg else f"{bread} اور جام",
+                f"{bread_desc}، آملیٹ اور چائے۔" if not no_egg else f"{bread_desc} جام کے ساتھ اور چائے۔",
+                380,
+                "پروٹین اور توانائی" if not no_egg else "توانائی",
+            ),
+            "lunch": meat_lunch,
+            "dinner": _meal("کھچڑی", "نرم چاول اور دال ملا کر پکائی ہوئی، ساتھ سادہ سلاد۔", 430, "ہلکی اور جلد ہضم"),
+            "snacks": [_meal("سیب", "ایک سیب۔", 90, "فائبر اور وٹامن")],
+        },
+        {
+            "day": "تیسرا دن",
+            "breakfast": _meal(dalia_name, f"ایک پیالی دلیہ {dalia_liquid} میں پکا کر، ساتھ ایک کیلا۔", 350, "توانائی اور فائبر"),
+            "lunch": _meal(f"آلو گوشت اور {roti}" if not vegetarian else f"آلو پالک اور {roti}",
+                           f"آلو گوشت کا سالن اور دو {roti}۔" if not vegetarian else f"آلو پالک کا سالن اور دو {roti}۔",
+                           520, "پروٹین اور آئرن"),
+            "dinner": _meal(f"بھنڈی اور {roti}", f"بھنڈی کی سبزی کے ساتھ دو {roti}۔", 420, "فائبر اور وٹامن"),
+            "snacks": [_meal("مالٹا یا کیلا", "ایک مالٹا یا ایک کیلا۔", 90, "وٹامن سی")],
+        },
+        {
+            "day": "چوتھا دن",
+            "breakfast": _meal(
+                f"انڈا بھجیا اور {roti}" if not no_egg else "چنے کا ناشتہ",
+                f"بھنا ہوا انڈا، ایک {roti} اور چائے۔" if not no_egg else "ایک چھوٹی پیالی ابلے چنے لیموں کے ساتھ اور چائے۔",
+                400,
+                "پروٹین",
+            ),
+            "lunch": _meal(f"چنے کی دال اور {roti}", f"چنے کی دال، دو {roti} اور سلاد۔", 490, "پروٹین اور فائبر"),
+            "dinner": _meal("سبزی پلاؤ", "مٹر، گاجر اور آلو کے ساتھ پکے ہوئے چاول۔", 470, "توانائی اور وٹامن"),
+            "snacks": [dahi_item],
+        },
+        {
+            "day": "پانچواں دن",
+            "breakfast": _meal(f"{paratha} اور دہی" if not dairy_free else f"{paratha} اور چائے",
+                               f"ایک {paratha} اور ایک چھوٹی پیالی دہی۔" if not dairy_free else f"ایک {paratha} اور ایک کپ چائے۔",
+                               430, "توانائی"),
+            "lunch": meat_dinner if vegetarian else _meal(f"مچھلی اور {roti}", f"تلی یا پکی ہوئی مچھلی، دو {roti} اور سلاد۔", 520, "پروٹین اور اچھی چکنائی"),
+            "dinner": _meal(f"پالک اور {roti}", f"پالک کی سبزی کے ساتھ دو {roti}۔", 400, "آئرن اور فائبر"),
+            "snacks": [_meal("گاجر یا کھیرا", "چند گاجر یا کھیرے کے ٹکڑے۔", 60, "فائبر اور پانی")],
+        },
+        {
+            "day": "چھٹا دن",
+            "breakfast": _meal(f"دودھ اور {bread}" if not dairy_free else f"چائے اور {bread}",
+                               f"ایک گلاس دودھ اور {bread_desc}۔" if not dairy_free else f"ایک کپ چائے اور {bread_desc}۔",
+                               350, "کیلشیم اور توانائی" if not dairy_free else "توانائی"),
+            "lunch": _meal("راجما یا لوبیا چاول", "راجما یا لوبیا کے ساتھ ایک پیالی چاول۔", 520, "پروٹین اور فائبر"),
+            "dinner": _meal("کڑھی چاول" if not dairy_free else f"دال اور {roti}",
+                            "دہی کی کڑھی کے ساتھ ایک پیالی چاول۔" if not dairy_free else f"دال کے ساتھ دو {roti}۔",
+                            460, "پروٹین اور توانائی"),
+            "snacks": [_meal("کیلا", "ایک کیلا۔", 100, "توانائی")],
+        },
+        {
+            "day": "ساتواں دن",
+            "breakfast": egg_breakfast,
+            "lunch": _meal("بریانی (چھوٹی پلیٹ)" if not vegetarian else "سبزی بریانی (چھوٹی پلیٹ)",
+                           f"ایک چھوٹی پلیٹ بریانی {biryani_side} کے ساتھ۔", 600, "توانائی اور پروٹین"),
+            "dinner": _meal(f"دال اور {roti}", f"دال، دو {roti} اور سادہ سلاد۔", 420, "پروٹین اور فائبر"),
+            "snacks": [_meal("موسمی پھل", "کوئی بھی موسمی پھل۔", 90, "وٹامن")],
+        },
+    ]
+
+
 def _fallback_diet_plan(
     condition: str = "general wellness",
     dietary_preferences: str = "balanced",
     restrictions: list[str] | None = None,
     goals: str = "general health",
+    language: str = "en",
 ) -> dict:
-    """Return a validated fallback plan when the model is unavailable."""
+    """A validated everyday Pakistani plan, used when the model is unavailable."""
     restrictions = restrictions or []
     context = f"{condition} {goals}".lower()
     restrictions_text = " ".join(restrictions).lower()
-    dairy_free = "dairy" in restrictions_text or "lactose" in restrictions_text
-    vegetarian = "vegetarian" in dietary_preferences.lower() or "vegan" in dietary_preferences.lower()
+    prefs = dietary_preferences.lower()
+    urdu = language == "ur"
+
+    dairy_free = any(t in restrictions_text for t in ("dairy", "lactose", "milk", "دودھ"))
+    no_egg = any(t in restrictions_text for t in ("egg", "anda", "انڈا"))
+    gluten_free = any(t in restrictions_text for t in ("gluten", "wheat", "roti", "گندم"))
+    vegetarian = "vegetarian" in prefs or "vegan" in prefs or "vegetarian" in restrictions_text
+
+    days = (_base_week_ur if urdu else _base_week_en)(
+        vegetarian, dairy_free, no_egg, gluten_free
+    )
+
+    tips = (
+        [
+            "دن میں 6 سے 8 گلاس پانی پیئیں، اگر ڈاکٹر نے پانی کم کرنے کو نہ کہا ہو۔",
+            "کھانا روز ایک ہی وقت پر کھائیں اور ناشتہ نہ چھوڑیں۔",
+            "ہر کھانے کے ساتھ تھوڑی سبزی یا سلاد ضرور رکھیں۔",
+            "تلی ہوئی چیزیں اور بازار کا کھانا ہفتے میں ایک بار سے زیادہ نہ کھائیں۔",
+        ]
+        if urdu
+        else [
+            "Drink 6 to 8 glasses of water a day, unless your doctor has told you to drink less.",
+            "Eat at the same times every day and do not skip breakfast.",
+            "Keep some sabzi or salad with every meal.",
+            "Keep fried food and bazaar food to no more than once a week.",
+        ]
+    )
 
     if _has_any(context, HYPERTENSION_TERMS):
-        protein_lunch = "Lentil Quinoa Bowl" if vegetarian else "Grilled Chicken Brown Rice Bowl"
-        dinner_name = "Bean and Vegetable Stew" if vegetarian else "Herb Baked Fish"
-        dinner_nutrients = "Fiber, magnesium, plant protein" if vegetarian else "Omega-3, protein, potassium"
-        dairy_alt = "fortified unsweetened soy milk" if dairy_free else "low-fat yogurt"
-        return {
-            "title": "7-Day Low-Sodium DASH-Style Diet Plan",
-            "summary": "A blood-pressure-focused plan emphasizing vegetables, fruits, legumes, whole grains, lean proteins, unsalted nuts or seeds, and low-sodium preparation. It avoids salty sauces and highly processed foods while keeping dairy optional based on restrictions.",
-            "plan": [
-                {
-                    "day": f"Day {i}",
-                    "breakfast": {
-                        "name": "Oat Berry Bowl",
-                        "description": f"Rolled oats with berries, chia seeds, cinnamon, and {dairy_alt}",
-                        "calories": 360,
-                        "nutrients": "Fiber, magnesium, potassium",
-                    },
-                    "lunch": {
-                        "name": protein_lunch,
-                        "description": "Whole grains, vegetables, herbs, olive oil, and no-salt-added protein",
-                        "calories": 470,
-                        "nutrients": "Protein, fiber, unsaturated fats",
-                    },
-                    "dinner": {
-                        "name": dinner_name,
-                        "description": "Served with sweet potato and steamed greens; seasoned with lemon, garlic, and herbs instead of salt",
-                        "calories": 510,
-                        "nutrients": dinner_nutrients,
-                    },
-                    "snacks": [
-                        {
-                            "name": "Fruit with Unsalted Seeds",
-                            "description": "Apple or orange with unsalted pumpkin or sunflower seeds",
-                            "calories": 180,
-                            "nutrients": "Fiber, minerals",
-                        }
-                    ],
-                }
-                for i in range(1, 8)
-            ],
-            "tips": [
-                "Keep sodium under 2,300 mg/day; ask a clinician whether a 1,500 mg/day target is appropriate.",
-                "Use no-salt-added foods and herbs/spices instead of salty sauces, pickles, processed meats, or packaged snacks.",
-                "Use potassium-rich foods for blood pressure only if you do not have kidney disease and are not on potassium-raising medicines.",
-                "This educational plan should be reviewed by a qualified clinician or dietitian for your diagnosis, medicines, labs, and allergies.",
-            ],
-        }
+        tips = _merge_tips(tips, _BP_TIPS_UR if urdu else _BP_TIPS_EN)
+    if _has_any(context, DIABETES_TERMS):
+        tips = _merge_tips(tips, _SUGAR_TIPS_UR if urdu else _SUGAR_TIPS_EN)
+    if _has_any(context, KIDNEY_TERMS):
+        tips = _merge_tips(tips, _KIDNEY_TIPS_UR if urdu else _KIDNEY_TIPS_EN)
+    if condition and condition.lower() != "general wellness":
+        tips = _merge_tips(tips, [_DOCTOR_TIP_UR if urdu else _DOCTOR_TIP_EN])
+
+    # The summary names the foods the plan is built from, so it has to drop the
+    # ones this person cannot eat — otherwise it advertises anda and dahi to
+    # someone who told us they avoid both.
+    if urdu:
+        title = "سات دن کا آسان پاکستانی کھانے کا پلان"
+        foods = []
+        if not no_egg:
+            foods.append("انڈا")
+        if not gluten_free:
+            foods.append("روٹی")
+        foods += ["دال", "چاول", "سبزی"]
+        if not dairy_free:
+            foods.append("دہی")
+        foods.append("پھل")
+        summary = (
+            "روزمرہ کے عام گھریلو کھانوں پر مبنی سات دن کا سادہ پلان — "
+            + "، ".join(foods)
+            + "۔ سب کچھ عام بازار سے مل جاتا ہے۔"
+        )
+    else:
+        title = "Simple 7-Day Pakistani Meal Plan"
+        foods = []
+        if not no_egg:
+            foods.append("anda")
+        foods.append("makai ki roti" if gluten_free else "roti")
+        foods += ["daal", "chawal", "sabzi"]
+        if not dairy_free:
+            foods.append("dahi")
+        foods.append("fruit")
+        summary = (
+            "A simple 7-day plan made from everyday home food — "
+            + ", ".join(foods[:-1])
+            + f" and {foods[-1]}. Everything is available in any local market."
+        )
 
     return {
-        "title": "General 7-Day Balanced Diet Plan",
-        "summary": "A 7-day balanced diet plan focusing on whole foods, lean proteins, and plenty of vegetables.",
-        "plan": [
-            {
-                "day": f"Day {i}",
-                "breakfast": {
-                    "name": "Oatmeal with Fruit",
-                    "description": "Steel-cut oats topped with banana, berries, and cinnamon",
-                    "calories": 350,
-                    "nutrients": "Fiber, vitamins, magnesium",
-                },
-                "lunch": {
-                    "name": "Protein Salad Bowl",
-                    "description": "Mixed greens with lean protein or beans, avocado, and olive oil dressing",
-                    "calories": 450,
-                    "nutrients": "Protein, healthy fats, fiber",
-                },
-                "dinner": {
-                    "name": "Balanced Grain Plate",
-                    "description": "Whole grains with vegetables and fish, poultry, tofu, or legumes",
-                    "calories": 500,
-                    "nutrients": "Protein, fiber, minerals",
-                },
-                "snacks": [
-                    {
-                        "name": "Fruit or Unsalted Seeds",
-                        "description": "A simple whole-food snack",
-                        "calories": 180,
-                        "nutrients": "Fiber, minerals",
-                    }
-                ],
-            }
-            for i in range(1, 8)
-        ],
-        "tips": [
-            "Stay hydrated with water unless your clinician has given fluid restrictions.",
-            "Eat meals at consistent times and include vegetables at most meals.",
-            "This educational plan should be reviewed by a qualified clinician or dietitian for your diagnosis, medicines, labs, and allergies.",
-        ],
+        "title": title,
+        "summary": summary,
+        "plan": days,
+        "tips": tips[:6],
     }

app/services/openrouter_client.py

@@ -1,58 +1,264 @@
-"""OpenRouter chat-completions client."""
+"""OpenRouter chat-completions client.
+
+The app runs on OpenRouter's free model tier, which is rate limited per day and
+occasionally retires model IDs. A single failed call used to take down both the
+health chatbot and the diet planner, so this client:
+
+* sends a list of models so OpenRouter can fall back automatically,
+* retries 429 / 5xx responses with backoff, honouring ``Retry-After``,
+* raises :class:`OpenRouterError` with a message that is safe to show a user.
+"""
 
 from __future__ import annotations
 
+import logging
+import time
+
 import httpx
+
 from app.config import get_settings
 
+logger = logging.getLogger(__name__)
 
-def complete_text(
-    prompt: str,
+OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
+
+MAX_ATTEMPTS = 3
+BACKOFF_SECONDS = (1.0, 3.0)
+RETRYABLE_STATUS = {408, 409, 429, 500, 502, 503, 504}
+
+# OpenRouter rejects the request outright with
+# "'models' array must have 3 items or fewer." past this, so the chain is
+# truncated rather than allowed to fail every call.
+MAX_MODELS = 3
+
+
+class OpenRouterError(RuntimeError):
+    """Raised when OpenRouter cannot produce a completion.
+
+    ``user_message`` is phrased for display in the UI; ``str(exc)`` keeps the
+    technical detail for the logs.
+    """
+
+    def __init__(self, detail: str, user_message: str, *, status_code: int | None = None):
+        super().__init__(detail)
+        self.user_message = user_message
+        self.status_code = status_code
+
+
+def _model_candidates() -> list[str]:
+    """Primary model first, then any configured fallbacks, de-duplicated."""
+    settings = get_settings()
+    candidates = [settings.openrouter_model.strip()]
+    candidates += [m.strip() for m in settings.openrouter_fallback_models.split(",")]
+
+    ordered: list[str] = []
+    for model in candidates:
+        if model and model not in ordered:
+            ordered.append(model)
+    return ordered[:MAX_MODELS]
+
+
+def _retry_after_seconds(response: httpx.Response, attempt: int) -> float:
+    header = response.headers.get("Retry-After")
+    if header:
+        try:
+            # Cap it so a long provider cooldown never stalls a web request.
+            return min(float(header), 10.0)
+        except ValueError:
+            pass
+    return BACKOFF_SECONDS[min(attempt, len(BACKOFF_SECONDS) - 1)]
+
+
+def _extract_content(data: dict) -> str:
+    choices = data.get("choices") or []
+    if not choices:
+        return ""
+
+    message = choices[0].get("message") or {}
+    content = message.get("content")
+
+    # Some providers return the text as a list of content parts.
+    if isinstance(content, list):
+        content = "".join(
+            part.get("text", "")
+            for part in content
+            if isinstance(part, dict)
+        )
+
+    if isinstance(content, str) and content.strip():
+        return content
+
+    # Reasoning models sometimes leave `content` empty and put the answer in
+    # `reasoning`. Better a reasoning dump than a dead chatbot.
+    reasoning = message.get("reasoning")
+    if isinstance(reasoning, str) and reasoning.strip():
+        return reasoning
+
+    return ""
+
+
+def complete_chat(
+    messages: list[dict],
     *,
-    system_prompt: str | None = None,
     temperature: float = 0.2,
     max_tokens: int = 2048,
+    reasoning: dict | None = None,
 ) -> str:
-    """Send a prompt to OpenRouter and return the assistant text."""
+    """Send a list of role/content messages and return the assistant text.
+
+    `reasoning` maps to OpenRouter's reasoning controls. The free tier routes to
+    reasoning models (a live run landed on nemotron, which spent 2087 of 3000
+    tokens thinking and truncated the answer), so callers that need a long,
+    complete answer should turn reasoning down and raise `max_tokens`.
+    """
     settings = get_settings()
     if not settings.openrouter_api_key:
-        raise RuntimeError("OPENROUTER_API_KEY is not configured.")
+        raise OpenRouterError(
+            "OPENROUTER_API_KEY is not configured.",
+            "The AI service is not configured yet. Please add an OpenRouter API key.",
+        )
+
+    models = _model_candidates()
+    payload: dict = {
+        "model": models[0],
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+    }
+    if len(models) > 1:
+        # OpenRouter tries each model in order when the earlier ones fail.
+        payload["models"] = models
+    if reasoning:
+        payload["reasoning"] = reasoning
+
+    headers = {
+        "Authorization": f"Bearer {settings.openrouter_api_key}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": settings.openrouter_site_url,
+        "X-Title": settings.openrouter_app_name,
+    }
+
+    last_error: OpenRouterError | None = None
+
+    for attempt in range(MAX_ATTEMPTS):
+        try:
+            response = httpx.post(
+                OPENROUTER_URL,
+                headers=headers,
+                json=payload,
+                timeout=settings.openrouter_timeout_seconds,
+            )
+        except httpx.RequestError as exc:
+            last_error = OpenRouterError(
+                f"OpenRouter request error: {exc}",
+                "Could not reach the AI service. Please check your connection and try again.",
+            )
+            logger.warning("OpenRouter attempt %s/%s failed: %s", attempt + 1, MAX_ATTEMPTS, exc)
+            if attempt < MAX_ATTEMPTS - 1:
+                time.sleep(BACKOFF_SECONDS[min(attempt, len(BACKOFF_SECONDS) - 1)])
+            continue
+
+        if response.status_code in RETRYABLE_STATUS:
+            detail = response.text[:500]
+            if response.status_code == 429:
+                user_message = (
+                    "The free AI service has hit its usage limit for now. "
+                    "Please wait a minute and try again."
+                )
+            else:
+                user_message = "The AI service is busy right now. Please try again in a moment."
+            last_error = OpenRouterError(
+                f"OpenRouter HTTP {response.status_code}: {detail}",
+                user_message,
+                status_code=response.status_code,
+            )
+            logger.warning(
+                "OpenRouter attempt %s/%s got HTTP %s: %s",
+                attempt + 1, MAX_ATTEMPTS, response.status_code, detail,
+            )
+            if attempt < MAX_ATTEMPTS - 1:
+                time.sleep(_retry_after_seconds(response, attempt))
+            continue
+
+        if response.status_code >= 400:
+            detail = response.text[:500]
+            logger.error("OpenRouter HTTP %s: %s", response.status_code, detail)
+            if response.status_code in (401, 403):
+                user_message = "The AI service rejected the configured API key."
+            elif response.status_code == 404:
+                user_message = (
+                    "The configured AI model is unavailable. "
+                    "Please update OPENROUTER_MODEL."
+                )
+            else:
+                user_message = "The AI service returned an error. Please try again."
+            raise OpenRouterError(
+                f"OpenRouter HTTP {response.status_code}: {detail}",
+                user_message,
+                status_code=response.status_code,
+            )
+
+        data = response.json()
+
+        # OpenRouter can return HTTP 200 with an error body.
+        if isinstance(data.get("error"), dict):
+            detail = str(data["error"].get("message", "unknown error"))
+            last_error = OpenRouterError(
+                f"OpenRouter error payload: {detail}",
+                "The AI service is unavailable right now. Please try again in a moment.",
+            )
+            logger.warning("OpenRouter returned an error payload: %s", detail)
+            if attempt < MAX_ATTEMPTS - 1:
+                time.sleep(BACKOFF_SECONDS[min(attempt, len(BACKOFF_SECONDS) - 1)])
+            continue
+
+        content = _extract_content(data)
+        if content:
+            choice = (data.get("choices") or [{}])[0]
+            if choice.get("finish_reason") == "length":
+                # Not fatal — the caller may still salvage it — but it is the
+                # usual reason a long structured answer comes back unparseable.
+                usage = data.get("usage") or {}
+                logger.warning(
+                    "OpenRouter response hit the token limit (model=%s, completion=%s, "
+                    "reasoning=%s). The answer is truncated.",
+                    data.get("model"),
+                    usage.get("completion_tokens"),
+                    (usage.get("completion_tokens_details") or {}).get("reasoning_tokens"),
+                )
+            return content
+
+        last_error = OpenRouterError(
+            "OpenRouter returned an empty response.",
+            "The AI service returned an empty answer. Please try again.",
+        )
+        logger.warning("OpenRouter returned an empty completion (model=%s)", data.get("model"))
+        if attempt < MAX_ATTEMPTS - 1:
+            time.sleep(BACKOFF_SECONDS[min(attempt, len(BACKOFF_SECONDS) - 1)])
 
-    messages = []
+    raise last_error or OpenRouterError(
+        "OpenRouter request failed.",
+        "The AI service is unavailable right now. Please try again in a moment.",
+    )
+
+
+def complete_text(
+    prompt: str,
+    *,
+    system_prompt: str | None = None,
+    temperature: float = 0.2,
+    max_tokens: int = 2048,
+    reasoning: dict | None = None,
+) -> str:
+    """Send a single prompt to OpenRouter and return the assistant text."""
+    messages: list[dict] = []
     if system_prompt:
         messages.append({"role": "system", "content": system_prompt})
     messages.append({"role": "user", "content": prompt})
 
-    response = httpx.post(
-        "https://openrouter.ai/api/v1/chat/completions",
-        headers={
-            "Authorization": f"Bearer {settings.openrouter_api_key}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": settings.openrouter_site_url,
-            "X-Title": settings.openrouter_app_name,
-        },
-        json={
-            "model": settings.openrouter_model,
-            "messages": messages,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        },
-        timeout=settings.openrouter_timeout_seconds,
+    return complete_chat(
+        messages,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        reasoning=reasoning,
     )
-    try:
-        response.raise_for_status()
-    except httpx.HTTPStatusError as exc:
-        detail = response.text[:500]
-        raise RuntimeError(
-            f"OpenRouter request failed with HTTP {response.status_code}: {detail}"
-        ) from exc
-
-    data = response.json()
-    choices = data.get("choices") or []
-    if not choices:
-        raise RuntimeError("OpenRouter returned no choices.")
-
-    content = choices[0].get("message", {}).get("content", "")
-    if not content:
-        raise RuntimeError("OpenRouter returned an empty response.")
-    return content