push

app/main.py

@@ -1,10 +1,811 @@
+# ##########################
+#         #NEW TEST#
+# ##########################
+# import os
+# import asyncio
+# import logging
+# from typing import List, Dict, Any, Optional
+# import re
+# from collections import OrderedDict
+# import time as _time
+# from datetime import datetime, timezone
+# import functools
+# from concurrent.futures import ThreadPoolExecutor
+# from asyncio import TimeoutError as AsyncTimeoutError
+
+# from dotenv import load_dotenv
+# load_dotenv()  # Load environment variables from .env into os.environ
+
+# from fastapi import FastAPI, HTTPException, Request
+# from fastapi.middleware.cors import CORSMiddleware
+# from fastapi import Query
+# from pydantic import BaseModel
+
+# # Import LangChain components
+# from langchain_openai import ChatOpenAI
+# from langchain.prompts import PromptTemplate
+# from langchain.schema.runnable import RunnableSequence
+# from langchain.schema import AIMessage
+
+# # Import the base LLM class to build our custom wrapper
+# from langchain.llms.base import LLM
+
+# from huggingface_hub import InferenceClient
+
+# # --- Supabase (server-side only) ---
+# from supabase import create_client, Client
+
+# # Set up logging
+# logging.basicConfig(level=logging.INFO)
+
+# # =========================
+# # Lightweight worker system
+# # =========================
+# GEN_CONCURRENCY_LIMIT = int(os.getenv("GEN_CONCURRENCY_LIMIT", "6"))   # inflight generations per process
+# GEN_THREAD_WORKERS    = int(os.getenv("GEN_THREAD_WORKERS", "8"))      # worker threads per process
+# REQUEST_TIMEOUT_SECONDS = float(os.getenv("REQUEST_TIMEOUT_SECONDS", "120"))
+# GEN_MAX_RETRIES       = int(os.getenv("GEN_MAX_RETRIES", "2"))
+# GEN_MAX_QUEUE         = int(os.getenv("GEN_MAX_QUEUE", "64"))          # soft queue size before 503
+
+# GEN_SEMAPHORE = asyncio.BoundedSemaphore(GEN_CONCURRENCY_LIMIT)
+# EXECUTOR = ThreadPoolExecutor(max_workers=GEN_THREAD_WORKERS)
+
+# _WAITERS = 0
+# _WAITERS_LOCK = asyncio.Lock()
+
+# class QueueOverloaded(Exception):
+#     pass
+# # =========================
+# # Idempotency (dedupe retries)
+# # =========================
+# _IDEMP_CACHE: "OrderedDict[str, tuple[float, dict]]" = OrderedDict()
+# _IDEMP_TTL_SECONDS = int(os.getenv("IDEMP_TTL_SECONDS", "600"))
+
+# def _idem_store(key: str, payload: dict) -> None:
+#     now = _time.time()
+#     _IDEMP_CACHE[key] = (now, payload)
+#     # prune expired / cap size
+#     for k in list(_IDEMP_CACHE.keys()):
+#         ts, _ = _IDEMP_CACHE[k]
+#         if now - ts > _IDEMP_TTL_SECONDS or len(_IDEMP_CACHE) > 500:
+#             _IDEMP_CACHE.pop(k, None)
+
+# def _idem_get(key: Optional[str]) -> Optional[dict]:
+#     if not key:
+#         return None
+#     v = _IDEMP_CACHE.get(key)
+#     if not v:
+#         return None
+#     ts, payload = v
+#     if _time.time() - ts > _IDEMP_TTL_SECONDS:
+#         _IDEMP_CACHE.pop(key, None)
+#         return None
+#     return payload
+
+# async def _enter_queue():
+#     global _WAITERS
+#     async with _WAITERS_LOCK:
+#         if _WAITERS >= GEN_MAX_QUEUE:
+#             raise QueueOverloaded("Server busy")
+#         _WAITERS += 1
+
+# async def _leave_queue():
+#     global _WAITERS
+#     async with _WAITERS_LOCK:
+#         _WAITERS = max(0, _WAITERS - 1)
+
+# async def _run_in_pool(fn, *args, **kwargs):
+#     loop = asyncio.get_running_loop()
+#     return await loop.run_in_executor(EXECUTOR, functools.partial(fn, *args, **kwargs))
+
+# async def resilient_invoke(chain, variables):
+#     """Queue -> semaphore -> (retry + timeout) -> blocking chain.invoke in worker thread."""
+#     await _enter_queue()
+#     try:
+#         async with GEN_SEMAPHORE:
+#             for attempt in range(GEN_MAX_RETRIES + 1):
+#                 try:
+#                     return await asyncio.wait_for(
+#                         _run_in_pool(chain.invoke, variables),
+#                         timeout=REQUEST_TIMEOUT_SECONDS,
+#                     )
+#                 except Exception as e:
+#                     last = attempt == GEN_MAX_RETRIES
+#                     logging.warning(f"[gen] attempt {attempt+1}/{GEN_MAX_RETRIES+1} failed: {e}")
+#                     if last:
+#                         raise
+#                     await asyncio.sleep(0.6 * (2 ** attempt))  # 0.6s, 1.2s, 2.4s ...
+#     finally:
+#         await _leave_queue()
+
+# # -----------------------------------------
+# # Optional: reuse HF clients to lower churn
+# # -----------------------------------------
+# _HF_CLIENTS: dict[tuple[str, str], InferenceClient] = {}
+
+# def get_cached_hf_client(provider: str, api_key: str) -> InferenceClient:
+#     key = (provider or "hf-inference", api_key or "")
+#     c = _HF_CLIENTS.get(key)
+#     if c is None:
+#         c = InferenceClient(provider=provider, api_key=api_key)
+#         _HF_CLIENTS[key] = c
+#     return c
+
+# # =========================
+# # Supabase client & helpers
+# # =========================
+# SUPABASE_URL = os.getenv("SUPABASE_URL")
+# SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+# ALLOW_PLAN_CREATE = os.getenv("ALLOW_PLAN_CREATE", "true").lower() == "true"
+
+# sb: Optional[Client] = None
+# if SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY:
+#     sb = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY)
+# else:
+#     logging.warning("Supabase env not configured (SUPABASE_URL / SUPABASE_SERVICE_ROLE_KEY). DB writes will be skipped.")
+
+# def now_iso() -> str:
+#     return datetime.now(timezone.utc).isoformat()
+
+# # Section → DB columns (same columns for Free & Full)
+# SECTION_MAP = {
+#     "prompt_ExecutiveSummary":              {"content":"executiveSummary","gen":"isExecutiveSummaryGenerating","done":"isExecutiveSummaryComplete"},
+#     "prompt_ExecutiveSummary_Free":         {"content":"executiveSummary","gen":"isExecutiveSummaryGenerating","done":"isExecutiveSummaryComplete"},
+#     "prompt_CompanyProfile":                {"content":"companyProfile","gen":"isCompanyProfileGenerating","done":"isCompanyProfileComplete"},
+#     "prompt_CompanyProfile_Free":           {"content":"companyProfile","gen":"isCompanyProfileGenerating","done":"isCompanyProfileComplete"},
+#     "prompt_MarketAnalysis":                {"content":"marketAnalysis","gen":"isMarketAnalysisGenerating","done":"isMarketAnalysisComplete"},
+#     "prompt_MarketAnalysis_Free":           {"content":"marketAnalysis","gen":"isMarketAnalysisGenerating","done":"isMarketAnalysisComplete"},
+#     "prompt_ProductOrService":              {"content":"productOrService","gen":"isProductOrServiceGenerating","done":"isProductOrServiceComplete"},
+#     "prompt_ProductOrService_Free":         {"content":"productOrService","gen":"isProductOrServiceGenerating","done":"isProductOrServiceComplete"},
+#     "prompt_BusinessModel":                 {"content":"businessModel","gen":"isBusinessModelGenerating","done":"isBusinessModelComplete"},
+#     "prompt_BusinessModel_Free":            {"content":"businessModel","gen":"isBusinessModelGenerating","done":"isBusinessModelComplete"},
+#     "prompt_MarketingGrowth":               {"content":"marketingGrowth","gen":"isMarketingGrowthGenerating","done":"isMarketingGrowthComplete"},
+#     "prompt_MarketingGrowth_Free":          {"content":"marketingGrowth","gen":"isMarketingGrowthGenerating","done":"isMarketingGrowthComplete"},
+#     "prompt_OperationsPlan":                {"content":"operationsPlan","gen":"isOperationsPlanGenerating","done":"isOperationsPlanComplete"},
+#     "prompt_OperationsPlan_Free":           {"content":"operationsPlan","gen":"isOperationsPlanGenerating","done":"isOperationsPlanComplete"},
+#     "prompt_ManagementTeam":                {"content":"managementTeam","gen":"isManagementTeamGenerating","done":"isManagementTeamComplete"},
+#     "prompt_ManagementTeam_Free":           {"content":"managementTeam","gen":"isManagementTeamGenerating","done":"isManagementTeamComplete"},
+#     "prompt_FinancialPlanFunding":          {"content":"financialPlanFunding","gen":"isFinancialPlanFundingGenerating","done":"isFinancialPlanFundingComplete"},
+# }
+
+# # FREE gating (visible subset only)
+# FREE_VISIBLE_KEYS = {
+#     "prompt_ExecutiveSummary_Free",
+#     "prompt_CompanyProfile_Free",
+#     "prompt_ProductOrService_Free",
+#     "prompt_MarketingGrowth_Free",
+# }
+# FREE_HIDDEN_KEYS = {
+#     "prompt_MarketAnalysis_Free",
+#     "prompt_BusinessModel_Free",
+#     "prompt_OperationsPlan_Free",
+#     "prompt_ManagementTeam_Free",
+#     "prompt_FinancialPlanFunding",
+# }
+# FULL_KEYS = {
+#     "prompt_ExecutiveSummary",
+#     "prompt_CompanyProfile",
+#     "prompt_MarketAnalysis",
+#     "prompt_ProductOrService",
+#     "prompt_BusinessModel",
+#     "prompt_MarketingGrowth",
+#     "prompt_OperationsPlan",
+#     "prompt_ManagementTeam",
+#     "prompt_FinancialPlanFunding",
+# }
+
+# def is_allowed_for_plan(plan_type: str, section_key: str) -> bool:
+#     if plan_type == "full":
+#         return section_key in FULL_KEYS or section_key in FREE_VISIBLE_KEYS or section_key in FREE_HIDDEN_KEYS
+#     # free
+#     return section_key in FREE_VISIBLE_KEYS
+
+# def ensure_plan_and_section(
+#     businessPlanId: Optional[str],
+#     *,
+#     userId: Optional[str],
+#     anonymousId: Optional[str],
+#     planType: Optional[str],
+#     countryCode: Optional[str],
+#     model: str,
+#     answers: Optional[List[str]],
+# ) -> str:
+#     """Return a valid businessPlanId. Create plan (and empty section row) if allowed and missing."""
+#     if sb is None:
+#         raise HTTPException(status_code=500, detail="Supabase not configured on server")
+
+#     if businessPlanId:
+#         # ensure a BusinessPlanSection row exists
+#         exists = sb.table("BusinessPlanSection").select("id").eq("businessPlanId", businessPlanId).limit(1).execute()
+#         if not exists.data:
+#             sb.table("BusinessPlanSection").insert({
+#                 "businessPlanId": businessPlanId,
+#                 "createdAt": now_iso(),
+#                 "updatedAt": now_iso(),
+#             }).execute()
+#         return businessPlanId
+
+#     if not ALLOW_PLAN_CREATE:
+#         raise HTTPException(status_code=400, detail="businessPlanId is required")
+
+#     if not (userId or anonymousId):
+#         raise HTTPException(status_code=400, detail="userId or anonymousId required to create plan")
+
+#     created = sb.table("BusinessPlan").insert({
+#         "summary": "Business Plan",
+#         "fullPlan": "",
+#         "model": model,
+#         "answers": answers or [],
+#         "planType": (planType or "free"),
+#         "countryCode": countryCode,
+#         "userId": userId,
+#         "anonymousId": anonymousId,
+#         "createdAt": now_iso(),
+#         "updatedAt": now_iso(),
+#     }).execute()
+#     new_id = created.data[0]["id"]
+#     sb.table("BusinessPlanSection").insert({
+#         "businessPlanId": new_id,
+#         "createdAt": now_iso(),
+#         "updatedAt": now_iso(),
+#     }).execute()
+#     return new_id
+
+# def set_section_generating(businessPlanId: str, sectionKey: str, on: bool) -> None:
+#     if sb is None: return
+#     m = SECTION_MAP[sectionKey]
+#     sb.table("BusinessPlanSection").upsert({
+#         "businessPlanId": businessPlanId,
+#         m["gen"]: on,
+#         "updatedAt": now_iso(),
+#     }, on_conflict="businessPlanId").execute()
+
+# def write_section_success(businessPlanId: str, sectionKey: str, content: str) -> None:
+#     if sb is None: return
+#     m = SECTION_MAP[sectionKey]
+#     sb.table("BusinessPlanSection").upsert({
+#         "businessPlanId": businessPlanId,
+#         m["content"]: content,
+#         m["gen"]: False,
+#         m["done"]: True,
+#         "updatedAt": now_iso(),
+#     }, on_conflict="businessPlanId").execute()
+
+# def write_section_error(businessPlanId: str, sectionKey: str, error_msg: str) -> None:
+#     if sb is None: return
+#     m = SECTION_MAP[sectionKey]
+#     sb.table("BusinessPlanSection").upsert({
+#         "businessPlanId": businessPlanId,
+#         m["gen"]: False,
+#         "updatedAt": now_iso(),
+#     }, on_conflict="businessPlanId").execute()
+
+# # Check for required environment variables
+# def check_environment_variables():
+#     hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+#     if not hf_token:
+#         logging.warning("⚠️ HUGGINGFACEHUB_API_TOKEN not set. Hugging Face models will not work properly.")
+#     else:
+#         logging.info("✅ HUGGINGFACEHUB_API_TOKEN is set")
+    
+#     openai_api_key = os.getenv("OPENAI_API_KEY")
+#     if not openai_api_key:
+#         logging.warning("⚠️ OPENAI_API_KEY not set. OpenAI GPT models will not work properly.")
+#     else:
+#         logging.info("✅ OPENAI_API_KEY is set")
+
+# # Run the environment variable check
+# check_environment_variables()
+
+# # Display information about model size limitations
+# logging.info("=" * 80)
+# logging.info("MODEL SIZE LIMITATIONS:")
+# logging.info("The free tier of Hugging Face Inference API limits models to 10GB.")
+# logging.info("Large models like Qwen-2.5-7B (15GB) and Llama-2-7B (13GB) exceed this limit.")
+# logging.info("We've configured smaller alternative models as replacements.")
+# logging.info("For full-sized models, upgrade to Hugging Face Pro subscription.")
+# logging.info("=" * 80)
+
+# # Create the FastAPI app
+# app = FastAPI()
+
+# # Add logging middleware
+# @app.middleware("http")
+# async def log_requests(request: Request, call_next):
+#     start_time = _time.time()
+#     response = await call_next(request)
+#     process_time = _time.time() - start_time
+#     logging.info(f"Request: {request.method} {request.url.path} - Status: {response.status_code} - Time: {process_time:.2f}s")
+#     return response
+
+# # Configure CORS for Hugging Face Spaces
+# allowed = [o.strip() for o in os.getenv("FASTAPI_ALLOWED_ORIGINS", "").split(",") if o.strip()]
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=allowed or ["http://localhost:3000"],
+#     allow_credentials=True,
+#     allow_methods=["POST","GET","OPTIONS"],
+#     allow_headers=["*"],
+#     expose_headers=["*"]
+# )
+# # Fixed list of business questions (order matters)
+# QUESTIONS = [
+#     "What is your business name?",
+#     "What product or service do you offer?",
+#     "Who is your target customer?",
+#     "What problem does your business solve?",
+#     "Who are your competitors?",
+#     "What is your unique value proposition?",
+#     "What is your pricing strategy?",
+#     "What are your short-term goals?",
+#     "What are your long-term goals?",
+#     "How will you acquire customers?",
+# ]
+
+# # Data model for incoming business plan generation requests
+# class GenerateRequest(BaseModel):
+#     answers: List[str]
+#     model: str
+#     prompt: str  # The prompt template from the database
+#     promptVariables: Dict[str, str]  # Variables to fill in the template
+#     provider: str  # The provider (e.g., "hf-inference", "together")
+#     temperature: float  # Temperature setting
+#     maxTokens: int  # Max tokens setting
+#     # New: minimal IDs for DB persistence
+#     businessPlanId: Optional[str] = None
+#     userId: Optional[str] = None
+#     anonymousId: Optional[str] = None
+#     planType: Optional[str] = "free"
+#     countryCode: Optional[str] = None
+#     sectionKey: Optional[str] = None   # required for per-section save
+#     idempotencyKey: Optional[str] = None  # ← ADD THIS
+
+# def generate_model_output(model: str, provider: str, api_key: str, prompt: str, max_tokens: int = 4000) -> str:
+#     """
+#     A helper function that wraps the Hugging Face Inference API call.
+#     """
+#     try:
+#         logging.info(f"Initializing InferenceClient with provider: {provider}")
+#         client = get_cached_hf_client(provider=provider, api_key=api_key)  # reuse client
+#         logging.info(f"Sending request to model: {model} with prompt length: {len(prompt)} and max_tokens: {max_tokens}")
+#         completion = client.chat.completions.create(
+#             model=model,
+#             messages=[{"role": "user", "content": prompt}],
+#             max_tokens=max_tokens,
+#         )
+#         logging.info(f"Successfully received response from model: {model} with content length: {len(completion.choices[0].message.content)}")
+#         return completion.choices[0].message.content
+#     except Exception as e:
+#         error_message = f"Error generating output with model {model}: {str(e)}"
+#         logging.error(error_message)
+#         # Re-raise the exception with more context
+#         raise Exception(error_message) from e
+
+# ###############################################################################
+# # HFInferenceLLM: A wrapper for Hugging Face models that matches the LLM interface.
+# ###############################################################################
+# class HFInferenceLLM(LLM):
+#     model: str = None
+#     provider: str = "hf-inference"
+#     api_key: str = ""
+#     max_tokens: int = 4000  # Increased from 500 to 4000 by default
+    
+
+#     def __init__(self, model: str, provider: str = "hf-inference", api_key: str = "", max_tokens: int = 4000):
+#         super().__init__()
+#         self.model = model
+#         self.provider = provider
+#         self.api_key = api_key
+#         self.max_tokens = max_tokens
+        
+#         # Validate API key
+#         if not api_key:
+#             logging.error(f"No API key provided for model {model}")
+#             raise ValueError(f"API key is required for Hugging Face Inference API access to {model}")
+        
+#         # Check if model is available
+#         try:
+#             # Create a client to validate connection
+#             _ = get_cached_hf_client(provider=provider, api_key=api_key)
+#             logging.info(f"Successfully initialized client for model: {model}")
+#         except Exception as e:
+#             logging.error(f"Failed to initialize client for model {model}: {str(e)}")
+#             raise ValueError(f"Could not initialize Hugging Face client for {model}: {str(e)}")
+
+#     @property
+#     def _llm_type(self) -> str:
+#         return "hf_inference"
+
+#     def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+#         """
+#         Calls the Hugging Face API using the provided prompt.
+#         The `stop` parameter is not implemented (or forwarded) here.
+#         """
+#         return generate_model_output(
+#             model=self.model,
+#             provider=self.provider,
+#             api_key=self.api_key,
+#             prompt=prompt,
+#             max_tokens=self.max_tokens
+#         )
+
+#     def get_num_tokens(self, prompt: str) -> int:
+#         """
+#         A simple implementation that counts tokens as space-separated words.
+#         You may replace this with a more accurate token counter.
+#         """
+#         return len(prompt.split())
+
+# ###############################################################################
+# # get_llm: Return an LLM instance based on the selected model.
+# ###############################################################################
+# def get_llm(model_name: str, provider: str = "hf-inference"):
+#     if model_name in ("BPGenerateAI", "BPSuggestionsAI") or model_name.lower().startswith("gpt-"):
+#         openai_api_key = os.getenv("OPENAI_API_KEY")
+#         if not openai_api_key:
+#             logging.error("OPENAI_API_KEY environment variable not set")
+#             raise ValueError("OPENAI_API_KEY environment variable is required for GPT models")
+#         if model_name == "BPGenerateAI":
+#             return ChatOpenAI(model_name="gpt-4.1-mini", temperature=0.7, max_tokens=6000, openai_api_key=openai_api_key)
+#         if model_name == "BPSuggestionsAI":
+#             return ChatOpenAI(model_name="gpt-4.1-nano", temperature=0.7, max_tokens=4000, openai_api_key=openai_api_key)
+#         return ChatOpenAI(model_name=model_name, temperature=0.7, max_tokens=4000, openai_api_key=openai_api_key)
+    
+#     hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+#     if not hf_token:
+#         logging.error("HUGGINGFACEHUB_API_TOKEN environment variable not set")
+#         raise ValueError("HUGGINGFACEHUB_API_TOKEN is required for Hugging Face models")
+#     return HFInferenceLLM(model=model_name, provider=provider, api_key=hf_token, max_tokens=4000)
+
+#     # hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+#     # if not hf_token:
+#     #     logging.error("HUGGINGFACEHUB_API_TOKEN environment variable not set")
+#     #     raise ValueError("HUGGINGFACEHUB_API_TOKEN environment variable is required for Hugging Face models")
+        
+#     # if model_name == "BPGenerateAI":
+#     #     openai_api_key = os.getenv("OPENAI_API_KEY")
+#     #     if not openai_api_key:
+#     #         logging.error("OPENAI_API_KEY environment variable not set")
+#     #         raise ValueError("OPENAI_API_KEY environment variable is required for GPT models")
+#     #     return ChatOpenAI(
+#     #         model_name="gpt-4.1-mini", 
+#     #         temperature=0.7, 
+#     #         max_tokens=6000,
+#     #         openai_api_key=openai_api_key
+#     #     )
+#     # elif model_name == "BPSuggestionsAI":
+#     #     openai_api_key = os.getenv("OPENAI_API_KEY")
+#     #     if not openai_api_key:
+#     #         logging.error("OPENAI_API_KEY environment variable not set")
+#     #         raise ValueError("OPENAI_API_KEY environment variable is required for GPT models")
+#     #     return ChatOpenAI(
+#     #         model_name="gpt-4.1-nano", 
+#     #         temperature=0.7, 
+#     #         max_tokens=4000,
+#     #         openai_api_key=openai_api_key
+#     #     )
+#     # elif model_name.lower() == "gpt-4.1-nano":
+#     #     openai_api_key = os.getenv("OPENAI_API_KEY")
+#     #     if not openai_api_key:
+#     #         raise ValueError("OPENAI_API_KEY is required for GPT models")
+#     #     return ChatOpenAI(
+#     #         model_name="gpt-4.1-nano", 
+#     #         temperature=0.7, 
+#     #         max_tokens=4000,
+#     #         openai_api_key=openai_api_key
+#     #     )
+#     # else:
+#     #     # For all other models, use the specified provider
+#     #     return HFInferenceLLM(
+#     #         model=model_name,
+#     #         provider=provider,
+#     #         api_key=hf_token,
+#     #         max_tokens=4000
+#     #     )
+
+# ###############################################################################
+# # FastAPI Endpoints
+# ###############################################################################
+
+# @app.get("/suggestions", response_model=Dict[str, Any])
+# async def get_suggestions(
+#     business_idea: str,
+#     model: str,
+#     question: str,
+#     prompt: str,
+#     provider: str,
+#     temperature: float,
+#     maxTokens: int,
+#     exclude: List[str] = Query([])
+# ) -> Dict[str, Any]:
+#     try:
+#         # Use the prompt from the frontend
+#         formatted_prompt = prompt.format(
+#             business_idea=business_idea,
+#             question=question,
+#             exclude=", ".join(exclude) if exclude else ""
+#         )
+
+#         # Get the LLM instance with frontend-provided configuration
+#         llm = get_llm(model, provider)
+#         if hasattr(llm, 'temperature'):
+#             llm.temperature = temperature
+#         if hasattr(llm, 'max_tokens'):
+#             llm.max_tokens = maxTokens
+
+#         suggestion_prompt = PromptTemplate(
+#             input_variables=[],
+#             template=formatted_prompt
+#         )
+#         suggestion_chain: RunnableSequence = suggestion_prompt | llm
+
+#         # resilience wrapper
+#         raw_result = await resilient_invoke(suggestion_chain, {})
+
+#         # Normalize AIMessage or list[AIMessage] → plain string
+#         if isinstance(raw_result, AIMessage):
+#             raw_text = raw_result.content
+#         elif (
+#             isinstance(raw_result, (list, tuple))
+#             and raw_result
+#             and isinstance(raw_result[0], AIMessage)
+#         ):
+#             raw_text = "\n".join(msg.content for msg in raw_result)
+#         else:
+#             raw_text = str(raw_result)
+
+#         # Clean up the suggestions
+#         suggestion_array = [
+#             re.sub(r'^\s*[\-\d\.\)\s]+', '', line).strip()
+#             for line in raw_text.split("\n")
+#             if line.strip()
+#         ]
+#         if not suggestion_array:
+#             suggestion_array = ["No suggestions available"]
+#         return {"suggestions": suggestion_array}
+#     except QueueOverloaded:
+#         raise HTTPException(status_code=503, detail="Server busy, please retry shortly")
+#     except AsyncTimeoutError:
+#         raise HTTPException(status_code=504, detail="Generation timed out")
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=f"Error generating suggestions: {str(e)}")
+
+# @app.post("/generate")
+# async def generate_business_plan(data: GenerateRequest, request: Request):
+#     """
+#     Generate a business plan using the provided prompt template and variables.
+#     - If sectionKey provided: generate that section, save to Supabase, return ACK + preview.
+#     - Else: one-shot body written to BusinessPlan.fullPlan (if businessPlanId is available/created).
+#     """
+#     try:
+#         # Idempotency fast path (header or body)
+#         idem_key = data.idempotencyKey or request.headers.get("Idempotency-Key")
+#         cached = _idem_get(idem_key)
+#         if cached:
+#             return cached
+
+#         # Get the LLM instance based on the selected model and provider
+#         logging.info(f"[plan={data.businessPlanId}|section={data.sectionKey}] model={data.model} provider={data.provider} init")
+#         llm_selected = get_llm(data.model, data.provider)
+#         # Get the LLM instance based on the selected model and provider
+#         # logging.info(f"Initializing model: {data.model} with provider: {data.provider}")
+#         # llm_selected = get_llm(data.model, data.provider)  # ✅ provider bugfix
+        
+#         # Set the temperature and max tokens from the request
+#         if hasattr(llm_selected, 'temperature'):
+#             llm_selected.temperature = data.temperature
+#         if hasattr(llm_selected, 'max_tokens'):
+#             llm_selected.max_tokens = data.maxTokens
+        
+#         # Create the prompt template
+#         plan_prompt = PromptTemplate(
+#             input_variables=list(data.promptVariables.keys()),
+#             template=data.prompt
+#         )
+#         plan_chain: RunnableSequence = plan_prompt | llm_selected
+        
+#         logging.info(f"Generating with model: {data.model}")
+
+#         # If we have a sectionKey, we will persist per-section
+#         if data.sectionKey:
+#             if data.sectionKey not in SECTION_MAP:
+#                 raise HTTPException(status_code=400, detail=f"Unknown sectionKey: {data.sectionKey}")
+
+#             # ensure plan + section container
+#             plan_id = ensure_plan_and_section(
+#                 data.businessPlanId,
+#                 userId=data.userId,
+#                 anonymousId=data.anonymousId,
+#                 planType=data.planType,
+#                 countryCode=data.countryCode or data.promptVariables.get("country"),
+#                 model=data.model,
+#                 answers=data.answers,
+#             )
+
+#             # authoritative planType from DB (if available)
+#             plan_type = (data.planType or "free").lower()
+#             try:
+#                 if sb is not None:
+#                     sel = sb.table("BusinessPlan").select("planType").eq("id", plan_id).limit(1).execute()
+#                     if sel.data:
+#                         plan_type = (sel.data[0]["planType"] or "free").lower()
+#             except Exception as _:
+#                 pass
+
+#             # FREE/FULL gating (small, safe)
+#             if not is_allowed_for_plan(plan_type, data.sectionKey):
+#                 raise HTTPException(status_code=403, detail=f"Section '{data.sectionKey}' not allowed for planType='{plan_type}'")
+
+#             # mark generating
+#             set_section_generating(plan_id, data.sectionKey, True)
+
+#             try:
+#                 # generate with resilience
+#                 raw_plan = await resilient_invoke(plan_chain, data.promptVariables)
+
+#                 # unwrap to text
+#                 if isinstance(raw_plan, AIMessage):
+#                     plan_text = raw_plan.content
+#                 elif isinstance(raw_plan, (list, tuple)) and raw_plan and isinstance(raw_plan[0], AIMessage):
+#                     plan_text = "\n".join(msg.content for msg in raw_plan)
+#                 else:
+#                     plan_text = str(raw_plan)
+
+#                 # persist success
+#                 write_section_success(plan_id, data.sectionKey, plan_text)
+
+#                 resp = {
+#                     "saved": True,
+#                     "businessPlanId": plan_id,
+#                     "sections": [{"key": data.sectionKey, "content": plan_text}],
+#                     "isComplete": True,
+#                     "currentSection": data.sectionKey,
+#                     "nextSectionIndex": None,
+#                 }
+#                 if idem_key: _idem_store(idem_key, resp)
+#                 return resp
+
+#             except QueueOverloaded:
+#                 # clear generating flag
+#                 write_section_error(plan_id, data.sectionKey, "queue overloaded")
+#                 raise HTTPException(status_code=503, detail="Server busy, please retry shortly")
+#             except AsyncTimeoutError:
+#                 write_section_error(plan_id, data.sectionKey, "timeout")
+#                 raise HTTPException(status_code=504, detail="Generation timed out")
+#             except Exception as e:
+#                 write_section_error(plan_id, data.sectionKey, str(e))
+#                 error_message = f"Error generating section with model {data.model}: {str(e)}"
+#                 logging.error(error_message)
+#                 raise HTTPException(status_code=500, detail=error_message)
+
+#         # No sectionKey → one-shot body (optional), persist to BusinessPlan.fullPlan
+#         try:
+#             # ensure plan row exists (may create if allowed)
+#             plan_id = ensure_plan_and_section(
+#                 data.businessPlanId,
+#                 userId=data.userId,
+#                 anonymousId=data.anonymousId,
+#                 planType=data.planType,
+#                 countryCode=data.countryCode or data.promptVariables.get("country"),
+#                 model=data.model,
+#                 answers=data.answers,
+#             )
+
+#             raw_plan = await resilient_invoke(plan_chain, data.promptVariables)
+
+#             if isinstance(raw_plan, AIMessage):
+#                 plan_text = raw_plan.content
+#             elif isinstance(raw_plan, (list, tuple)) and raw_plan and isinstance(raw_plan[0], AIMessage):
+#                 plan_text = "\n".join(msg.content for msg in raw_plan)
+#             else:
+#                 plan_text = str(raw_plan)
+
+#             # best-effort persist
+#             if sb is not None:
+#                 sb.table("BusinessPlan").update({
+#                     "fullPlan": plan_text,
+#                     "updatedAt": now_iso(),
+#                 }).eq("id", plan_id).execute()
+
+#             resp = {
+#                 "summary": "Generated Business Plan",
+#                 "plan": plan_text,
+#                 "businessPlanId": plan_id,
+#                 "saved": True
+#             }
+#             if idem_key: _idem_store(idem_key, resp)
+#             return resp
+
+#         except QueueOverloaded:
+#             raise HTTPException(status_code=503, detail="Server busy, please retry shortly")
+#         except AsyncTimeoutError:
+#             raise HTTPException(status_code=504, detail="Generation timed out")
+#         except Exception as e:
+#             error_message = f"Error generating business plan with model {data.model}: {str(e)}"
+#             logging.error(error_message)
+#             raise HTTPException(status_code=500, detail=error_message)
+
+#     except HTTPException:
+#         raise
+#     except Exception as e:
+#         error_message = f"Error initializing model {data.model}: {str(e)}"
+#         logging.error(error_message)
+#         raise HTTPException(status_code=500, detail=error_message)
+
+# @app.get("/")
+# def root():
+#     return {"status": "FastAPI is running 🚀"}
+
+# @app.get("/health")
+# def health_check():
+#     """
+#     Health check endpoint to verify API connectivity and model availability.
+#     """
+#     hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+#     openai_api_key = os.getenv("OPENAI_API_KEY")
+    
+#     status = {
+#         "api": "healthy",
+#         "models": {}
+#     }
+
+#     status["queue"] = {
+#         "waiters": _WAITERS,
+#         "concurrency_limit": GEN_CONCURRENCY_LIMIT,
+#     }
+    
+#     # Check Hugging Face models
+#     models_to_check = ["Mistral", "Qwen-2.5", "Llama", "Gemma", "Phi-3"]
+    
+#     # for model_name in models_to_check:
+#     #     try:
+#     #         # Just initialize the model without running inference
+#     #         if model_name == "":
+#     #             client = InferenceClient(provider="hf-inference", api_key=hf_token)
+#     #             # Just a simple check that the model exists
+#     #             client.model_info("mistralai/Mistral-7B-Instruct-v0.3")
+#     #             status["models"][model_name] = "available"
+#     #         elif model_name == "Qwen-2.5":
+#     #             # Check Qwen-2.5 availability
+#     #             client = InferenceClient(provider="hf-inference", api_key=hf_token)
+#     #             client.model_info("Qwen/Qwen2.5-7B-Instruct")
+#     #             status["models"][model_name] = "available"
+#     #         elif model_name == "Llama":
+#     #             # Check Llama availability
+#     #             client = InferenceClient(provider="hf-inference", api_key=hf_token)
+#     #             client.model_info("meta-llama/Llama-2-7b-chat-hf")
+#     #             status["models"][model_name] = "available"
+#     #         else:
+#     #             # Simplified check for other models
+#     #             status["models"][model_name] = "not checked"
+#     #     except Exception as e:
+#     #         status["models"][model_name] = f"error: {str(e)}"
+    
+#     # Check OpenAI/GPT model
+#     if openai_api_key:
+#         try:
+#             status["models"]["GPT"] = "available"
+#         except Exception as e:
+#             status["models"]["GPT"] = f"error: {str(e)}"
+#     else:
+#         status["models"]["GPT"] = "unavailable (missing API key)"
+    
+#     return status
+
+
+
 ##########################
-        #NEW TEST#
+#        #NEW TEST#
 ##########################
 import os
 import asyncio
 import logging
 from typing import List, Dict, Any, Optional
+# Literal fallback for older Python
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
 import re
 from collections import OrderedDict
 import time as _time
@@ -55,6 +856,7 @@ _WAITERS_LOCK = asyncio.Lock()
 
 class QueueOverloaded(Exception):
     pass
+
 # =========================
 # Idempotency (dedupe retries)
 # =========================
@@ -62,6 +864,8 @@ _IDEMP_CACHE: "OrderedDict[str, tuple[float, dict]]" = OrderedDict()
 _IDEMP_TTL_SECONDS = int(os.getenv("IDEMP_TTL_SECONDS", "600"))
 
 def _idem_store(key: str, payload: dict) -> None:
+    if not key:
+        return
     now = _time.time()
     _IDEMP_CACHE[key] = (now, payload)
     # prune expired / cap size
@@ -280,6 +1084,68 @@ def write_section_error(businessPlanId: str, sectionKey: str, error_msg: str) ->
         "updatedAt": now_iso(),
     }, on_conflict="businessPlanId").execute()
 
+# ---- Completion & full plan rebuild helpers ----
+
+# Order used when we rebuild the full plan text
+SECTION_ORDER_FULL = [
+    "prompt_ExecutiveSummary",
+    "prompt_CompanyProfile",
+    "prompt_MarketAnalysis",
+    "prompt_ProductOrService",
+    "prompt_BusinessModel",
+    "prompt_MarketingGrowth",
+    "prompt_OperationsPlan",
+    "prompt_ManagementTeam",
+    "prompt_FinancialPlanFunding",
+]
+SECTION_ORDER_FREE = [
+    "prompt_ExecutiveSummary_Free",
+    "prompt_CompanyProfile_Free",
+    "prompt_ProductOrService_Free",
+    "prompt_MarketingGrowth_Free",
+]
+
+def _required_keys_for_plan(plan_type: str) -> List[str]:
+    return SECTION_ORDER_FULL if (plan_type or "free").lower() == "full" else SECTION_ORDER_FREE
+
+def _content_col_for_key(section_key: str) -> str:
+    return SECTION_MAP[section_key]["content"]
+
+def check_and_update_plan_completion(businessPlanId: str, plan_type: str) -> None:
+    if sb is None: return
+    required = [k for k in _required_keys_for_plan(plan_type) if k in SECTION_MAP]
+    if not required:
+        return
+    cols = [SECTION_MAP[k]["done"] for k in required]
+    sel = sb.table("BusinessPlanSection").select(",".join(cols)).eq("businessPlanId", businessPlanId).limit(1).execute()
+    if not sel.data:
+        return
+    done = all(sel.data[0].get(c) for c in cols)
+    if done:
+        rebuild_full_plan(businessPlanId, plan_type)
+
+def rebuild_full_plan(businessPlanId: str, plan_type: str) -> None:
+    if sb is None: return
+    order = [k for k in _required_keys_for_plan(plan_type) if k in SECTION_MAP]
+    cols = list({SECTION_MAP[k]["content"] for k in order})
+    res = sb.table("BusinessPlanSection").select(",".join(cols)).eq("businessPlanId", businessPlanId).limit(1).execute()
+    if not res.data:
+        return
+    row = res.data[0]
+    parts: list[str] = []
+    for k in order:
+        m = SECTION_MAP.get(k)
+        if not m: 
+            continue
+        txt = (row.get(m["content"]) or "").strip()
+        if txt:
+            parts.append(txt)
+    full_text = "\n\n".join(parts)
+    sb.table("BusinessPlan").update({
+        "fullPlan": full_text,
+        "updatedAt": now_iso()
+    }).eq("id", businessPlanId).execute()
+
 # Check for required environment variables
 def check_environment_variables():
     hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
@@ -328,6 +1194,7 @@ app.add_middleware(
     allow_headers=["*"],
     expose_headers=["*"]
 )
+
 # Fixed list of business questions (order matters)
 QUESTIONS = [
     "What is your business name?",
@@ -342,7 +1209,9 @@ QUESTIONS = [
     "How will you acquire customers?",
 ]
 
-# Data model for incoming business plan generation requests
+# ----------------------
+# Request models
+# ----------------------
 class GenerateRequest(BaseModel):
     answers: List[str]
     model: str
@@ -358,8 +1227,37 @@ class GenerateRequest(BaseModel):
     planType: Optional[str] = "free"
     countryCode: Optional[str] = None
     sectionKey: Optional[str] = None   # required for per-section save
-    idempotencyKey: Optional[str] = None  # ← ADD THIS
+    idempotencyKey: Optional[str] = None  # idempotency
+
+class SectionSpec(BaseModel):
+    key: str
+    prompt: str
+    promptVariables: Dict[str, str]
+
+class StartPlanGenerationRequest(BaseModel):
+    # generation config
+    model: str
+    provider: str
+    temperature: float
+    maxTokens: int
+
+    # plan context
+    planType: Literal["free", "full"] = "free"
+    countryCode: Optional[str] = None
+    answers: List[str]
+
+    # identity / persistence
+    businessPlanId: Optional[str] = None
+    userId: Optional[str] = None
+    anonymousId: Optional[str] = None
+    idempotencyKey: Optional[str] = None
 
+    # all sections at once
+    sections: List[SectionSpec]
+
+# ----------------------
+# LLM plumbing
+# ----------------------
 def generate_model_output(model: str, provider: str, api_key: str, prompt: str, max_tokens: int = 4000) -> str:
     """
     A helper function that wraps the Hugging Face Inference API call.
@@ -378,18 +1276,13 @@ def generate_model_output(model: str, provider: str, api_key: str, prompt: str,
     except Exception as e:
         error_message = f"Error generating output with model {model}: {str(e)}"
         logging.error(error_message)
-        # Re-raise the exception with more context
         raise Exception(error_message) from e
 
-###############################################################################
-# HFInferenceLLM: A wrapper for Hugging Face models that matches the LLM interface.
-###############################################################################
 class HFInferenceLLM(LLM):
     model: str = None
     provider: str = "hf-inference"
     api_key: str = ""
     max_tokens: int = 4000  # Increased from 500 to 4000 by default
-    
 
     def __init__(self, model: str, provider: str = "hf-inference", api_key: str = "", max_tokens: int = 4000):
         super().__init__()
@@ -405,7 +1298,6 @@ class HFInferenceLLM(LLM):
         
         # Check if model is available
         try:
-            # Create a client to validate connection
             _ = get_cached_hf_client(provider=provider, api_key=api_key)
             logging.info(f"Successfully initialized client for model: {model}")
         except Exception as e:
@@ -417,10 +1309,6 @@ class HFInferenceLLM(LLM):
         return "hf_inference"
 
     def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
-        """
-        Calls the Hugging Face API using the provided prompt.
-        The `stop` parameter is not implemented (or forwarded) here.
-        """
         return generate_model_output(
             model=self.model,
             provider=self.provider,
@@ -430,15 +1318,8 @@ class HFInferenceLLM(LLM):
         )
 
     def get_num_tokens(self, prompt: str) -> int:
-        """
-        A simple implementation that counts tokens as space-separated words.
-        You may replace this with a more accurate token counter.
-        """
         return len(prompt.split())
 
-###############################################################################
-# get_llm: Return an LLM instance based on the selected model.
-###############################################################################
 def get_llm(model_name: str, provider: str = "hf-inference"):
     if model_name in ("BPGenerateAI", "BPSuggestionsAI") or model_name.lower().startswith("gpt-"):
         openai_api_key = os.getenv("OPENAI_API_KEY")
@@ -457,56 +1338,9 @@ def get_llm(model_name: str, provider: str = "hf-inference"):
         raise ValueError("HUGGINGFACEHUB_API_TOKEN is required for Hugging Face models")
     return HFInferenceLLM(model=model_name, provider=provider, api_key=hf_token, max_tokens=4000)
 
-    # hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
-    # if not hf_token:
-    #     logging.error("HUGGINGFACEHUB_API_TOKEN environment variable not set")
-    #     raise ValueError("HUGGINGFACEHUB_API_TOKEN environment variable is required for Hugging Face models")
-        
-    # if model_name == "BPGenerateAI":
-    #     openai_api_key = os.getenv("OPENAI_API_KEY")
-    #     if not openai_api_key:
-    #         logging.error("OPENAI_API_KEY environment variable not set")
-    #         raise ValueError("OPENAI_API_KEY environment variable is required for GPT models")
-    #     return ChatOpenAI(
-    #         model_name="gpt-4.1-mini", 
-    #         temperature=0.7, 
-    #         max_tokens=6000,
-    #         openai_api_key=openai_api_key
-    #     )
-    # elif model_name == "BPSuggestionsAI":
-    #     openai_api_key = os.getenv("OPENAI_API_KEY")
-    #     if not openai_api_key:
-    #         logging.error("OPENAI_API_KEY environment variable not set")
-    #         raise ValueError("OPENAI_API_KEY environment variable is required for GPT models")
-    #     return ChatOpenAI(
-    #         model_name="gpt-4.1-nano", 
-    #         temperature=0.7, 
-    #         max_tokens=4000,
-    #         openai_api_key=openai_api_key
-    #     )
-    # elif model_name.lower() == "gpt-4.1-nano":
-    #     openai_api_key = os.getenv("OPENAI_API_KEY")
-    #     if not openai_api_key:
-    #         raise ValueError("OPENAI_API_KEY is required for GPT models")
-    #     return ChatOpenAI(
-    #         model_name="gpt-4.1-nano", 
-    #         temperature=0.7, 
-    #         max_tokens=4000,
-    #         openai_api_key=openai_api_key
-    #     )
-    # else:
-    #     # For all other models, use the specified provider
-    #     return HFInferenceLLM(
-    #         model=model_name,
-    #         provider=provider,
-    #         api_key=hf_token,
-    #         max_tokens=4000
-    #     )
-
-###############################################################################
+# ----------------------
 # FastAPI Endpoints
-###############################################################################
-
+# ----------------------
 @app.get("/suggestions", response_model=Dict[str, Any])
 async def get_suggestions(
     business_idea: str,
@@ -519,14 +1353,12 @@ async def get_suggestions(
     exclude: List[str] = Query([])
 ) -> Dict[str, Any]:
     try:
-        # Use the prompt from the frontend
         formatted_prompt = prompt.format(
             business_idea=business_idea,
             question=question,
             exclude=", ".join(exclude) if exclude else ""
         )
 
-        # Get the LLM instance with frontend-provided configuration
         llm = get_llm(model, provider)
         if hasattr(llm, 'temperature'):
             llm.temperature = temperature
@@ -539,10 +1371,8 @@ async def get_suggestions(
         )
         suggestion_chain: RunnableSequence = suggestion_prompt | llm
 
-        # resilience wrapper
         raw_result = await resilient_invoke(suggestion_chain, {})
 
-        # Normalize AIMessage or list[AIMessage] → plain string
         if isinstance(raw_result, AIMessage):
             raw_text = raw_result.content
         elif (
@@ -554,7 +1384,6 @@ async def get_suggestions(
         else:
             raw_text = str(raw_result)
 
-        # Clean up the suggestions
         suggestion_array = [
             re.sub(r'^\s*[\-\d\.\)\s]+', '', line).strip()
             for line in raw_text.split("\n")
@@ -570,6 +1399,110 @@ async def get_suggestions(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error generating suggestions: {str(e)}")
 
+# ---- Bulk plan generation worker ----
+async def run_section_job(
+    *,
+    plan_id: str,
+    plan_type: str,
+    section: SectionSpec,
+    model_name: str,
+    provider: str,
+    temperature: float,
+    max_tokens: int,
+) -> None:
+    if section.key not in SECTION_MAP:
+        logging.warning(f"[plan={plan_id}] Unknown section key '{section.key}', skipping")
+        return
+
+    if not is_allowed_for_plan(plan_type, section.key):
+        logging.info(f"[plan={plan_id}] Section '{section.key}' not allowed for planType='{plan_type}', skipping")
+        return
+
+    llm = get_llm(model_name, provider)
+    if hasattr(llm, "temperature"): llm.temperature = temperature
+    if hasattr(llm, "max_tokens"):  llm.max_tokens = max_tokens
+
+    tmpl = PromptTemplate(input_variables=list(section.promptVariables.keys()), template=section.prompt)
+    chain: RunnableSequence = tmpl | llm
+
+    set_section_generating(plan_id, section.key, True)
+
+    try:
+        raw = await resilient_invoke(chain, section.promptVariables)
+        text = (
+            raw.content if isinstance(raw, AIMessage)
+            else ("\n".join(m.content for m in raw) if isinstance(raw, (list, tuple)) and raw and isinstance(raw[0], AIMessage)
+                  else str(raw))
+        )
+        write_section_success(plan_id, section.key, text)
+    except Exception as e:
+        write_section_error(plan_id, section.key, str(e))
+        logging.exception(f"[plan={plan_id}] section={section.key} failed: {e}")
+    finally:
+        try:
+            check_and_update_plan_completion(plan_id, plan_type)
+        except Exception as e:
+            logging.warning(f"[plan={plan_id}] completion check failed: {e}")
+
+# ---- New bulk endpoint: send all sections at once ----
+@app.post("/start_plan_generation")
+async def start_plan_generation(req: StartPlanGenerationRequest, request: Request):
+    # Idempotency
+    idem_key = req.idempotencyKey or request.headers.get("Idempotency-Key")
+    cached = _idem_get(idem_key)
+    if cached:
+        return cached
+
+    # ensure plan exists (may create)
+    plan_id = ensure_plan_and_section(
+        req.businessPlanId,
+        userId=req.userId,
+        anonymousId=req.anonymousId,
+        planType=req.planType,
+        countryCode=req.countryCode,
+        model=req.model,
+        answers=req.answers,
+    )
+
+    # authoritative planType from DB if present
+    plan_type = (req.planType or "free").lower()
+    try:
+        if sb is not None:
+            sel = sb.table("BusinessPlan").select("planType").eq("id", plan_id).limit(1).execute()
+            if sel.data:
+                plan_type = (sel.data[0]["planType"] or "free").lower()
+    except Exception:
+        pass
+
+    # Filter only allowed sections & mark generating up-front for instant UI feedback
+    allowed_sections = [s for s in req.sections if is_allowed_for_plan(plan_type, s.key)]
+    for s in allowed_sections:
+        try:
+            set_section_generating(plan_id, s.key, True)
+        except Exception:
+            pass
+
+    # Spawn jobs (fire-and-forget; resilient_invoke handles queue/timeout/retry)
+    for s in allowed_sections:
+        asyncio.create_task(run_section_job(
+            plan_id=plan_id,
+            plan_type=plan_type,
+            section=s,
+            model_name=req.model,
+            provider=req.provider,
+            temperature=req.temperature,
+            max_tokens=req.maxTokens,
+        ))
+
+    resp = {
+        "businessPlanId": plan_id,
+        "acceptedSections": [s.key for s in allowed_sections],
+        "status": "processing"
+    }
+    _idem_store(idem_key, resp)
+    return resp
+
+# ---- Legacy / single-section endpoint (kept intact) ----
 @app.post("/generate")
 async def generate_business_plan(data: GenerateRequest, request: Request):
     """
@@ -587,9 +1520,6 @@ async def generate_business_plan(data: GenerateRequest, request: Request):
         # Get the LLM instance based on the selected model and provider
         logging.info(f"[plan={data.businessPlanId}|section={data.sectionKey}] model={data.model} provider={data.provider} init")
         llm_selected = get_llm(data.model, data.provider)
-        # Get the LLM instance based on the selected model and provider
-        # logging.info(f"Initializing model: {data.model} with provider: {data.provider}")
-        # llm_selected = get_llm(data.model, data.provider)  # ✅ provider bugfix
         
         # Set the temperature and max tokens from the request
         if hasattr(llm_selected, 'temperature'):
@@ -632,7 +1562,7 @@ async def generate_business_plan(data: GenerateRequest, request: Request):
             except Exception as _:
                 pass
 
-            # FREE/FULL gating (small, safe)
+            # FREE/FULL gating
             if not is_allowed_for_plan(plan_type, data.sectionKey):
                 raise HTTPException(status_code=403, detail=f"Section '{data.sectionKey}' not allowed for planType='{plan_type}'")
 
@@ -654,6 +1584,12 @@ async def generate_business_plan(data: GenerateRequest, request: Request):
                 # persist success
                 write_section_success(plan_id, data.sectionKey, plan_text)
 
+                # check completion for this plan after single-section regen
+                try:
+                    check_and_update_plan_completion(plan_id, plan_type)
+                except Exception:
+                    pass
+
                 resp = {
                     "saved": True,
                     "businessPlanId": plan_id,
@@ -662,7 +1598,7 @@ async def generate_business_plan(data: GenerateRequest, request: Request):
                     "currentSection": data.sectionKey,
                     "nextSectionIndex": None,
                 }
-                if idem_key: _idem_store(idem_key, resp)
+                _idem_store(idem_key, resp)
                 return resp
 
             except QueueOverloaded:
@@ -713,7 +1649,7 @@ async def generate_business_plan(data: GenerateRequest, request: Request):
                 "businessPlanId": plan_id,
                 "saved": True
             }
-            if idem_key: _idem_store(idem_key, resp)
+            _idem_store(idem_key, resp)
             return resp
 
         except QueueOverloaded:
@@ -754,37 +1690,10 @@ def health_check():
         "concurrency_limit": GEN_CONCURRENCY_LIMIT,
     }
     
-    # Check Hugging Face models
-    models_to_check = ["Mistral", "Qwen-2.5", "Llama", "Gemma", "Phi-3"]
-    
-    # for model_name in models_to_check:
-    #     try:
-    #         # Just initialize the model without running inference
-    #         if model_name == "":
-    #             client = InferenceClient(provider="hf-inference", api_key=hf_token)
-    #             # Just a simple check that the model exists
-    #             client.model_info("mistralai/Mistral-7B-Instruct-v0.3")
-    #             status["models"][model_name] = "available"
-    #         elif model_name == "Qwen-2.5":
-    #             # Check Qwen-2.5 availability
-    #             client = InferenceClient(provider="hf-inference", api_key=hf_token)
-    #             client.model_info("Qwen/Qwen2.5-7B-Instruct")
-    #             status["models"][model_name] = "available"
-    #         elif model_name == "Llama":
-    #             # Check Llama availability
-    #             client = InferenceClient(provider="hf-inference", api_key=hf_token)
-    #             client.model_info("meta-llama/Llama-2-7b-chat-hf")
-    #             status["models"][model_name] = "available"
-    #         else:
-    #             # Simplified check for other models
-    #             status["models"][model_name] = "not checked"
-    #     except Exception as e:
-    #         status["models"][model_name] = f"error: {str(e)}"
-    
     # Check OpenAI/GPT model
     if openai_api_key:
         try:
-            status["models"]["GPT"] = "available" 
+            status["models"]["GPT"] = "available"
         except Exception as e:
             status["models"]["GPT"] = f"error: {str(e)}"
     else: