Update app.py

app.py

@@ -1,186 +1,573 @@
-###############################################################################
-# app.py — stable, cached, with on-demand TTS
-###############################################################################
-import os, re, json, uuid, asyncio, base64, io, hashlib, tempfile
-from pathlib import Path
-import streamlit as st; st.set_page_config("AI Report & Slides", layout="wide")
-import pandas as pd, matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt
-from fpdf import FPDF, HTMLMixin
-from markdown import markdown
-try: from markdown_it import MarkdownIt
-except ImportError: MarkdownIt = None
-from pptx import Presentation
-from pptx.util import Inches, Pt
+import streamlit as st
+from PIL import Image
+from io import BytesIO
 from google import genai
 from google.genai import types
-from google.adk.agents import LlmAgent, SequentialAgent
-from google.adk.runners import Runner
-from google.adk.sessions import InMemorySessionService
-from langchain_experimental.agents import create_pandas_dataframe_agent
-from langchain_google_genai import ChatGoogleGenerativeAI
-
-# ————————————————————————————————————————————————————————————— CONFIG
-FONT_DIR = Path(__file__).parent
-FONT_REG = FONT_DIR/"NotoSans-Regular.ttf"; FONT_BLD = FONT_DIR/"NotoSans-Bold.ttf"
-FONT = "NotoSans"; SLIDES = 7
+import re
+import time
+import os
+import wave
+import io
+import tempfile
+import base64
+
+# Disable Streamlit analytics (prevents PermissionError in some environments)
+os.environ["STREAMLIT_ANALYTICS_ENABLED"] = "false"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 1. CONFIGURATION
+# ─────────────────────────────────────────────────────────────────────────────
+
+# 1.1 Load your Google API key from environment or Streamlit secrets
+try:
+    API_KEY = st.secrets["GOOGLE_API_KEY"]
+except (AttributeError, KeyError):
+    API_KEY = os.environ.get("GOOGLE_API_KEY")
+
+if not API_KEY:
+    st.error("Please set GOOGLE_API_KEY in your environment variables or Streamlit secrets")
+    st.stop()
+
+# 1.2 Initialize the GenAI client
+try:
+    client = genai.Client(api_key=API_KEY)
+except Exception as e:
+    st.error(f"Failed to initialize GenAI Client: {e}")
+    st.stop()
+
+# 1.3 Constants
+CATEGORY_MODEL = "gemini-2.0-flash-exp"
+GENERATION_MODEL = "gemini-2.0-flash-exp-image-generation"
 TTS_MODEL = "gemini-2.5-flash-preview-tts"
 
-API_KEY = os.getenv("GEMINI_API_KEY"); st.experimental_set_query_params()
-if not API_KEY: st.error("Set GEMINI_API_KEY"); st.stop()
-GEM = genai.Client(api_key=API_KEY)
-
-# ————————————————————————————————————————————————————————————— HELPERS
-fix_bullet = lambda t: t.replace("\x95","•")
-def pcm_to_wav(raw, rate=24_000):
-    import wave, contextlib; buf=io.BytesIO()
-    with contextlib.closing(wave.open(buf,'wb')) as w:
-        w.setnchannels(1); w.setsampwidth(2); w.setframerate(rate); w.writeframes(raw)
-    return buf.getvalue()
-def df_hash(df): return hashlib.sha1(pd.util.hash_pandas_object(df, index=True).values).hexdigest()
-
-@st.cache_data(show_spinner=False)
-def tts_cached(text):
-    txt = text[:500]+"…" if len(text)>500 else text
+# 1.4 Helper to parse numbered steps out of Gemini text
+def parse_numbered_steps(text):
+    text = "\n" + text
+    steps = re.findall(r"\n\s*(\d+).\s*(.*)", text, re.MULTILINE)
+    return [(int(num), desc.strip()) for num, desc in steps]
+
+# 1.5 FIXED File Upload Handler
+def handle_uploaded_file(uploaded_file):
+    """Enhanced file handler with better error handling and validation for Hugging Face Spaces."""
+    if uploaded_file is None:
+        return None, "No file uploaded"
+    
+    try:
+        # Get file info
+        file_details = {
+            "filename": uploaded_file.name,
+            "filetype": uploaded_file.type,
+            "filesize": uploaded_file.size
+        }
+        
+        # Validate file size (limit to 5MB for better performance in HF Spaces)
+        max_size = 5 * 1024 * 1024  # 5MB
+        if uploaded_file.size > max_size:
+            return None, f"File size ({uploaded_file.size / 1024 / 1024:.1f}MB) exceeds limit (5MB)"
+        
+        # Validate file type more strictly
+        allowed_types = ['image/jpeg', 'image/jpg', 'image/png', 'image/bmp', 'image/gif']
+        if uploaded_file.type not in allowed_types:
+            return None, f"Unsupported file type: {uploaded_file.type}. Allowed: JPG, PNG, BMP, GIF"
+        
+        # Read file bytes with error handling
+        try:
+            file_bytes = uploaded_file.read()
+            if len(file_bytes) == 0:
+                return None, "File appears to be empty"
+        except Exception as read_error:
+            return None, f"Error reading file: {str(read_error)}"
+        
+        # Reset file pointer for PIL
+        uploaded_file.seek(0)
+        
+        # Try to open and validate the image
+        try:
+            image = Image.open(BytesIO(file_bytes))
+            
+            # Verify image is valid
+            image.verify()
+            
+            # Reopen for actual use (verify() closes the image)
+            image = Image.open(BytesIO(file_bytes))
+            
+            # Convert to RGB if necessary (handles RGBA, P mode, etc.)
+            if image.mode not in ('RGB', 'L'):
+                image = image.convert('RGB')
+            
+            # Resize if too large (helps with memory in HF Spaces)
+            max_dimension = 1024
+            if max(image.size) > max_dimension:
+                image.thumbnail((max_dimension, max_dimension), Image.Resampling.LANCZOS)
+            
+            return image, "Success"
+            
+        except Exception as img_error:
+            return None, f"Invalid or corrupted image: {str(img_error)}"
+            
+    except Exception as e:
+        return None, f"Unexpected error processing file: {str(e)}"
+
+# 1.6 TTS Generation Function with better error handling
+@st.cache_data
+def generate_tts_audio(_client, text_to_speak):
+    """Generates audio from text using Gemini TTS and returns the audio data and its mime type."""
     try:
-        r=GEM.models.generate_content(
-            model=TTS_MODEL, contents=f"Say clearly: {txt}",
+        # Limit text length to prevent timeout
+        if len(text_to_speak) > 500:
+            text_to_speak = text_to_speak[:500] + "..."
+            
+        response = _client.models.generate_content(
+            model=TTS_MODEL,
+            contents=f"Say clearly: {text_to_speak}",
             config=types.GenerateContentConfig(
                 response_modalities=["AUDIO"],
                 speech_config=types.SpeechConfig(
                     voice_config=types.VoiceConfig(
-                        prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name="Kore")))))
-        audio=r.candidates[0].content.parts[0].inline_data
-        return audio.data, audio.mime_type
-    except Exception as e: st.error(f"TTS error: {e}"); return None,None
-
-# — cached heavy builders —
-@st.cache_resource(show_spinner=False)
-def pandas_agent(dfh): return create_pandas_dataframe_agent(
-        llm=ChatGoogleGenerativeAI(model="gemini-2.0-flash",google_api_key=API_KEY),
-        df=st.session_state.df, verbose=False, allow_dangerous_code=True)
-
-@st.cache_resource(show_spinner=False)
-def charts(descs, dfh):
-    pa=pandas_agent(dfh); mp={}
-    for d in descs:
-        pa.run(f"Create a {d} using matplotlib")
-        p=Path(tempfile.gettempdir())/f"{uuid.uuid4()}.png"
-        plt.gcf().savefig(p,dpi=300,bbox_inches="tight"); plt.close()
-        mp[d]=str(p)
-    return mp
-
-@st.cache_resource(show_spinner=False)
-def build_pdf(html_md):
-    html_md=fix_bullet(html_md)
-    html=(MarkdownIt("commonmark",{"breaks":True}).enable("table").render(html_md)
-          if MarkdownIt else markdown(html_md,extensions=["tables"]))
-    dummy=FPDF(); width=dummy.w-2*dummy.l_margin; px=lambda mm:int(mm*dummy.k)
-    html=re.sub(r'(<table[^>]*>)',r'\1<font size="8">',html).replace('</table>','</font></table>')
-    html=re.sub(r'<table(?![^>]*width=)',lambda m:f'<table width="{px(width)}"',html)
-    html=re.sub(r'<img[^>]+src="([^"]+\.png)"[^>]*>',
-                lambda m:f'<img src="{m.group(1)}" width="{int(width)}" />',html)
-    class PDF(FPDF,HTMLMixin): pass
-    pdf=PDF(); pdf.set_auto_page_break(True,15)
-    for s,f in [("",FONT_REG),("B",FONT_BLD),("I",FONT_REG),("BI",FONT_BLD)]: pdf.add_font(FONT,s,str(f),uni=True)
-    pdf.set_fallback_fonts([FONT]); pdf.add_page()
-    pdf.set_font(FONT,"B",18); pdf.cell(0,12,"AI-Generated Business Report",ln=True); pdf.ln(3)
-    pdf.set_font(FONT,"",11); pdf.write_html(html)
-    return bytes(pdf.output(dest="S"))
-
-@st.cache_resource(show_spinner=False)
-def build_pptx(slides, mp):
-    prs=Presentation(); layout=prs.slide_layouts[1]
-    for i,raw in enumerate(slides):
-        raw=fix_bullet(raw)
-        title,*body=filter(None,[l.strip().lstrip('*').strip() for l in re.sub(r'<.*?>','',raw).splitlines()])
-        sl=prs.slides.add_slide(layout); sl.shapes.title.text=title
-        tf=sl.placeholders[1].text_frame; tf.clear()
-        for line in body: p=tf.add_paragraph(); p.text=line; p.font.size=Pt(24)
-        m=re.search(r'<generate_chart:\s*"([^"]+)"',raw)
-        if m and m.group(1) in mp:
-            sl.shapes.add_picture(mp[m.group(1)],Inches(1),Inches(4),width=Inches(8))
-    buf=io.BytesIO(); prs.save(buf); return buf.getvalue()
-
-# —————————————————————————————————————————————————���——————————— UI INPUT
-mode = st.radio("Output:",["Report","Presentation","Both"],horizontal=True)
-upl  = st.file_uploader("CSV / XLSX",["csv","xlsx"])
-ctx  = st.text_area("Optional business context")
-if not st.button("🚀 Generate"): st.stop()
-if not upl: st.warning("Upload data"); st.stop()
-
-# ————————————————————————————————————————————————————————————— HEAVY GEN
-if "generated" not in st.session_state:
+                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                            voice_name='Kore',
+                        )
+                    )
+                ),
+            )
+        )
+        audio_part = response.candidates[0].content.parts[0]
+        return audio_part.inline_data.data, audio_part.inline_data.mime_type
+    except Exception as e:
+        st.error(f"Failed to generate narration: {e}")
+        return None, None
+
+# 1.7 NEW HELPER FUNCTION TO CREATE A WAV FILE IN MEMORY
+def _convert_pcm_to_wav(pcm_data, sample_rate=24000, channels=1, sample_width=2):
+    """Wraps raw PCM audio data in a WAV container in memory."""
+    audio_buffer = io.BytesIO()
+    with wave.open(audio_buffer, 'wb') as wf:
+        wf.setnchannels(channels)
+        wf.setsampwidth(sample_width)
+        wf.setframerate(sample_rate)
+        wf.writeframes(pcm_data)
+    audio_buffer.seek(0)
+    return audio_buffer.getvalue()
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 2. SESSION STATE SETUP
+# ─────────────────────────────────────────────────────────────────────────────
+
+if "app_state" not in st.session_state:
+    st.session_state.app_state = {
+        "steps": [], "images": {}, "tools_list": [], "current_step": 1,
+        "done_flags": {}, "notes": {}, "timers": {}, "category": None,
+        "prompt_sent": False, "timer_running": {}, "last_tick": {},
+        "project_title": "", "project_description": "", "upcycling_options": [],
+        "plan_approved": False, "initial_plan": "", "user_image": None,
+        "upload_error": None, "upload_attempts": 0, "last_uploaded_file": None
+    }
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 3. LAYOUT & FUNCTIONS
+# ─────────────────────────────────────────────────────────────────────────────
+
+def reset_state():
+    """Clear out all session state so user can start fresh."""
+    st.session_state.app_state = {
+        "steps": [], "images": {}, "tools_list": [], "current_step": 1,
+        "done_flags": {}, "notes": {}, "timers": {}, "category": None,
+        "prompt_sent": False, "timer_running": {}, "last_tick": {},
+        "project_title": "", "project_description": "", "upcycling_options": [],
+        "plan_approved": False, "initial_plan": "", "user_image": None,
+        "upload_error": None, "upload_attempts": 0, "last_uploaded_file": None
+    }
+    st.success("✅ Reset complete!")
+    st.rerun()
+
+def send_text_request(model_name, prompt, image):
+    """Helper to send requests that expect only a text response."""
     try:
-        st.session_state.df = pd.read_excel(upl) if upl.name.lower().endswith(".xlsx") else pd.read_csv(upl)
-    except Exception as e: st.error(e); st.stop()
-    h = df_hash(st.session_state.df)
-    # Agents
-    agents=[]
-    if mode in ("Report","Both"):
-        agents.append(LlmAgent(name="ReportAgent",model="gemini-2.5-flash",
-                               instruction="Write exec-level Markdown report with <generate_chart:\"…\">"))
-    if mode in ("Presentation","Both"):
-        agents.append(LlmAgent(name="PresentationAgent",model="gemini-2.5-flash",
-                               instruction=f"Create {SLIDES} slides starting 'Slide X:' with <generate_chart:\"…\"> tags"))
-    root=SequentialAgent(name="root",sub_agents=agents)
-    svc=InMemorySessionService(); sid=str(uuid.uuid4())
-    asyncio.run(svc.create_session(app_name="app",user_id="u",session_id=sid))
-    runner=Runner(agent=root,app_name="app",session_service=svc)
-    context={"dataset_info":{"shape":st.session_state.df.shape},
-             "user_context":ctx,"preview":st.session_state.df.head().to_dict()}
-    result={}
-    async def _go():
-        async for ev in runner.run_async(user_id="u",session_id=sid,
-                                         new_message=types.Content(role="user",
-                                                                   parts=[types.Part(text=json.dumps(context))])):
-            if ev.is_final_response(): result[ev.author]=ev.content.parts[0].text
-    asyncio.run(_go())
-    st.session_state.result=result
-    # charts
-    tags=re.findall(r'<generate_chart:\s*"([^"]+)"',"\n".join(result.values()))
-    mp=charts(tuple(tags),h); st.session_state.chart_map=mp
-    # slides & docs
-    if "ReportAgent" in result:
-        md=result["ReportAgent"]
-        md_full=md
-        for d,p in mp.items(): md_full=re.sub(rf'<generate_chart:\s*"{re.escape(d)}"',f'<img src="{p}"',md_full)
-        st.session_state.pdf=build_pdf(md_full)
-    if "PresentationAgent" in result:
-        slides=[s.strip() for s in re.split(r'\bSlide\s+\d+:',result["PresentationAgent"]) if s.strip()][:SLIDES]
-        st.session_state.slides=slides
-        st.session_state.pptx=build_pptx(tuple(slides),mp)
-    st.session_state.idx=0
-    st.session_state.generated=True
-
-# ————————————————————————————————————————————————————————————— TABS UI
-if mode=="Both": tab_rep,tab_pre=st.tabs(["Report","Slides"])
-else: tab_rep=tab_pre=st
-
-if mode in ("Report","Both"):
-    md_prev=st.session_state.result["ReportAgent"]
-    for d,p in st.session_state.chart_map.items():
-        b64=base64.b64encode(open(p,"rb").read()).decode()
-        md_prev=re.sub(rf'<generate_chart:\s*"{re.escape(d)}"',f'<img src="data:image/png;base64,{b64}"',md_prev)
-    with tab_rep:
-        st.markdown(md_prev,unsafe_allow_html=True)
-        st.download_button("Download PDF",st.session_state.pdf,"report.pdf","application/pdf")
-
-if mode in ("Presentation","Both"):
-    with tab_pre:
-        slides=st.session_state.slides
-        idx=st.session_state.idx
-        st.markdown(f"### Slide {idx+1}/{len(slides)}")
-        st.write(fix_bullet(slides[idx]))
-        if st.button("🔊 Speak",key="speak"):
-            with st.spinner("TTS…"):
-                aud,mime=tts_cached(slides[idx])
-                if aud:
-                    st.audio(pcm_to_wav(aud) if mime.startswith("audio/raw") else aud,
-                             format="audio/wav" if mime.startswith("audio/raw") else mime)
-        col1,col2=st.columns(2)
-        if col1.button("⬅️",disabled=idx==0): st.session_state.idx-=1; st.rerun()
-        if col2.button("➡️",disabled=idx==len(slides)-1): st.session_state.idx+=1; st.rerun()
-        st.download_button("Download PPTX",st.session_state.pptx,
-                           "presentation.pptx",
-                           "application/vnd.openxmlformats-officedocument.presentationml.presentation")
-###############################################################################
+        chat = client.chats.create(model=model_name)
+        response = chat.send_message([prompt, image])
+        response_text = "".join(part.text for part in response.candidates[0].content.parts if part.text)
+        return response_text.strip()
+    except Exception as e:
+        st.error(f"Error with model {model_name}: {str(e)}")
+        return None
+
+def initial_analysis(image, context_text):
+    """First pass with AI: get category, then title, description, and initial plan."""
+    if image is None:
+        st.error("No valid image provided for analysis")
+        return
+        
+    st.session_state.app_state['user_image'] = image
+
+    with st.spinner("🤖 Analyzing your project and preparing a plan..."):
+        category_prompt = (
+            "You are an expert DIY assistant. Analyze the user's image and context. "
+            f"Context: '{context_text}'. "
+            "Categorize the project into ONE of the following: "
+            "Home Appliance Repair, Automotive Maintenance, Gardening & Urban Farming, "
+            "Upcycling & Sustainable Crafts, or DIY Project Creation. "
+            "Reply with ONLY the category name."
+        )
+        category = send_text_request(CATEGORY_MODEL, category_prompt, image)
+        if not category: return
+        st.session_state.app_state['category'] = category
+
+        plan_prompt = f"""
+        You are an expert DIY assistant in the category: {category}.
+        User Context: "{context_text if context_text else 'No context provided.'}"
+        Based on the image and context, perform the following:
+        1.  **Title:** Create a short, clear title for this project.
+        2.  **Description:** Write a brief, one-paragraph description of the goal.
+        3.  **Initial Plan:**
+            - If 'Upcycling & Sustainable Crafts' AND no specific project is mentioned, propose three distinct project options as a numbered list under "UPCYCLING OPTIONS:".
+            - For all other cases, briefly outline the main stages of the proposed solution.
+        Structure your response EXACTLY like this:
+        TITLE: [Your title]
+        DESCRIPTION: [Your description]
+        INITIAL PLAN:
+        [Your plan or 3 options]
+        """
+        plan_response = send_text_request(GENERATION_MODEL, plan_prompt, image)
+        if not plan_response: return
+
+    try:
+        st.session_state.app_state['project_title'] = re.search(r"TITLE:\s*(.*)", plan_response).group(1).strip()
+        st.session_state.app_state['project_description'] = re.search(r"DESCRIPTION:\s*(.*)", plan_response, re.DOTALL).group(1).strip()
+        initial_plan_text = re.search(r"INITIAL PLAN:\s*(.*)", plan_response, re.DOTALL).group(1).strip()
+
+        if "UPCYCLING OPTIONS:" in initial_plan_text:
+            options = re.findall(r"^\s*\d+\.\s*(.*)", initial_plan_text, re.MULTILINE)
+            st.session_state.app_state['upcycling_options'] = options
+        else:
+            st.session_state.app_state['initial_plan'] = initial_plan_text
+
+        st.session_state.app_state['prompt_sent'] = True
+        if context_text:
+            st.session_state.app_state['plan_approved'] = True
+            generate_detailed_guide_with_images()
+        else:
+            st.session_state.app_state['plan_approved'] = False
+    except AttributeError:
+        st.error("The AI response was not in the expected format. Please try again.")
+        st.session_state.app_state['prompt_sent'] = False
+
+def generate_detailed_guide_with_images(selected_option=None):
+    """Generates the detailed guide with steps and illustrations."""
+    image = st.session_state.app_state.get('user_image')
+    if not image:
+        st.error("Image not found. Please start over."); return
+
+    context = f"The user has approved the plan for '{st.session_state.app_state['project_title']}'."
+    if selected_option:
+        context = f"The user chose the upcycling project: '{selected_option}'."
+
+    detailed_prompt = f"""
+    You are a DIY expert. The user wants to proceed with the project titled "{st.session_state.app_state['project_title']}".
+    {context}
+    Provide a detailed guide. For each step, you MUST provide a simple, clear illustrative image.
+    Format your response EXACTLY like this:
+    TOOLS AND MATERIALS:
+    - Tool A
+    - Material B
+    STEPS(Maximum 7 steps):
+    1. First step instructions.
+    2. Second step instructions...
+    """
+    with st.spinner("🛠️ Generating your detailed guide with illustrations..."):
+        try:
+            chat = client.chats.create(
+                model=GENERATION_MODEL,
+                config=types.GenerateContentConfig(response_modalities=["Text", "Image"])
+            )
+            full_resp = chat.send_message([detailed_prompt, image])
+            gen_parts = full_resp.candidates[0].content.parts
+
+            combined_text = ""
+            inline_images = []
+            for part in gen_parts:
+                if part.text is not None:
+                    combined_text += part.text + "\n"
+                if part.inline_data is not None:
+                    img = Image.open(BytesIO(part.inline_data.data))
+                    inline_images.append(img)
+            combined_text = combined_text.strip()
+
+            tools_section = re.search(r"TOOLS AND MATERIALS:\s*(.*?)\s*STEPS:", combined_text, re.DOTALL).group(1).strip()
+            steps_section = re.search(r"STEPS:\s*(.*)", combined_text, re.DOTALL).group(1).strip()
+            parsed_steps = parse_numbered_steps(steps_section)
+
+            st.session_state.app_state['tools_list'] = [line.strip("- ").strip() for line in tools_section.split('\n') if line.strip()]
+            st.session_state.app_state['steps'] = parsed_steps
+            st.session_state.app_state['images'] = {idx: inline_images[idx - 1] for idx, _ in parsed_steps if idx - 1 < len(inline_images)}
+
+            for idx, step_text in parsed_steps:
+                st.session_state.app_state['done_flags'][idx] = False
+                st.session_state.app_state['notes'][idx] = ""
+                timer_match = re.search(r"wait\s+for\s+(\d+)\s+(seconds?|minutes?)", step_text.lower())
+                if timer_match:
+                    val, unit = int(timer_match.group(1)), timer_match.group(2)
+                    st.session_state.app_state['timers'][idx] = val * (60 if "minute" in unit else 1)
+                else:
+                    st.session_state.app_state['timers'][idx] = 0
+        except Exception as e:
+            st.error(f"Failed to generate or parse the illustrated guide: {str(e)}")
+
+def render_sidebar_navigation():
+    st.sidebar.markdown("## Steps Navigation")
+    steps = st.session_state.app_state['steps']
+    if not steps: return
+    total_steps = len(steps)
+    completed = sum(1 for done in st.session_state.app_state['done_flags'].values() if done)
+    st.sidebar.progress(completed / total_steps if total_steps > 0 else 0)
+    st.sidebar.write(f"Progress: {completed}/{total_steps} steps")
+    for (idx, _) in steps:
+        is_done = st.session_state.app_state['done_flags'].get(idx, False)
+        label = f"{'✓' if is_done else '·'} Step {idx}"
+        if st.sidebar.button(label, key=f"nav_{idx}"):
+            st.session_state.app_state['current_step'] = idx
+            st.rerun()
+
+def render_tools_list():
+    if st.session_state.app_state['tools_list']:
+        with st.expander("🔧 Required Tools & Materials", expanded=True):
+            for item in st.session_state.app_state['tools_list']:
+                st.markdown(f"- {item}")
+
+def render_step(idx, text):
+    total = len(st.session_state.app_state['steps'])
+    st.markdown(f"### Step {idx} of {total}")
+    st.write(text)
+
+    # FINALIZED TTS Integration
+    if st.button(f"🔊 Narrate Step {idx}", key=f"tts_{idx}"):
+        with st.spinner("Generating narration..."):
+            audio_data, mime_type = generate_tts_audio(client, text)
+
+            if audio_data:
+                # Check if the audio is raw PCM data
+                if 'L16' in mime_type or 'pcm' in mime_type:
+                    st.info("Raw audio format detected. Converting to WAV for playback...")
+                    # Convert the raw PCM data to a playable WAV format
+                    wav_data = _convert_pcm_to_wav(audio_data)
+                    st.audio(wav_data, format="audio/wav")
+                else:
+                    # If it's already in a standard format (like mp3, ogg), play it directly
+                    st.audio(audio_data, format=mime_type)
+            else:
+                st.error("Could not generate audio.")
+
+    if idx in st.session_state.app_state['images']:
+        st.image(
+            st.session_state.app_state['images'][idx],
+            caption=f"Illustration for step {idx}",
+            use_container_width=True
+        )
+
+    done = st.checkbox("✅ Mark this step as completed", value=st.session_state.app_state['done_flags'].get(idx, False), key=f"done_{idx}")
+    st.session_state.app_state['done_flags'][idx] = done
+    notes = st.text_area("📝 Your notes for this step:", value=st.session_state.app_state['notes'].get(idx, ""), height=100, key=f"notes_{idx}")
+    st.session_state.app_state['notes'][idx] = notes
+    st.markdown("---")
+    col1, col2, col3 = st.columns([1, 2, 1])
+    if idx > 1 and col1.button("⬅️ Previous", key=f"prev_{idx}"):
+        st.session_state.app_state['current_step'] -= 1
+        st.rerun()
+    if idx < total and col3.button("Next ➡️", key=f"next_{idx}"):
+        st.session_state.app_state['current_step'] += 1
+        st.rerun()
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 4. APP LAYOUT - FIXED UPLOAD SECTION
+# ─────────────────────────────────────────────────────────────────────────────
+
+st.set_page_config(page_title="NeoFix DIY Assistant", page_icon="🛠️", layout="wide")
+st.title("🛠️ NeoFix AI-Powered DIY Assistant")
+
+with st.expander("ℹ️ How it works", expanded=False):
+    st.write("""
+    1.  **Upload a photo** of your project or the item you want to fix or build (appliance, car part, plant, craft project).
+    2.  **(Optional) Describe your goal** for more accurate results.
+    3.  **Review the Plan.** The AI will propose a plan. If you didn't provide a description, you'll be asked to approve it.
+    4.  **Get Your Guide** with tools and illustrated step-by-step instructions.
+    5.  **Follow the Steps** using the interactive checklist.
+    """)
+
+if not st.session_state.app_state['prompt_sent']:
+    st.markdown("---")
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        st.markdown("### 📷 Upload Project Image")
+        
+        # Show upload status
+        if st.session_state.app_state.get('upload_error'):
+            st.error(f"Upload Error: {st.session_state.app_state['upload_error']}")
+        
+        if st.session_state.app_state.get('upload_attempts', 0) > 0:
+            st.info(f"Upload attempts: {st.session_state.app_state['upload_attempts']}")
+        
+        # IMPROVED File uploader with unique key to force refresh
+        upload_key = f"file_upload_{st.session_state.app_state.get('upload_attempts', 0)}"
+        uploaded_image = st.file_uploader(
+            "Choose an image file",
+            type=["jpg", "jpeg", "png", "bmp", "gif"],
+            accept_multiple_files=False,
+            key=upload_key,
+            help="Supported: JPG, PNG, BMP, GIF (max 5MB)"
+        )
+        
+        # Process uploaded image immediately
+        processed_image = None
+        upload_status = ""
+        
+        if uploaded_image is not None:
+            # Check if this is a new file upload
+            current_file_id = f"{uploaded_image.name}_{uploaded_image.size}"
+            if current_file_id != st.session_state.app_state.get('last_uploaded_file'):
+                st.session_state.app_state['last_uploaded_file'] = current_file_id
+                
+                with st.spinner("Processing uploaded image..."):
+                    processed_image, upload_status = handle_uploaded_file(uploaded_image)
+                
+                if processed_image is not None:
+                    st.session_state.app_state['upload_error'] = None
+                    st.success("✅ Image uploaded and processed successfully!")
+                    st.image(processed_image, caption="Uploaded image preview", use_container_width=True)
+                else:
+                    st.session_state.app_state['upload_error'] = upload_status
+                    st.session_state.app_state['upload_attempts'] += 1
+                    st.error(f"❌ {upload_status}")
+            else:
+                # File already processed, show cached result
+                if st.session_state.app_state.get('upload_error') is None:
+                    processed_image, _ = handle_uploaded_file(uploaded_image)
+                    if processed_image:
+                        st.success("✅ Image ready for analysis!")
+                        st.image(processed_image, caption="Uploaded image preview", use_container_width=True)
+        
+        # Alternative camera input
+        st.markdown("##### Alternative: Take a photo")
+        camera_image = st.camera_input("Take a picture", key=f"camera_{st.session_state.app_state.get('upload_attempts', 0)}")
+        if camera_image and not uploaded_image:
+            with st.spinner("Processing camera image..."):
+                processed_image, upload_status = handle_uploaded_file(camera_image)
+            if processed_image is not None:
+                st.session_state.app_state['upload_error'] = None
+                st.success("✅ Photo captured and processed!")
+                st.image(processed_image, caption="Camera photo preview", use_container_width=True)
+            else:
+                st.error(f"❌ {upload_status}")
+        
+        context_text = st.text_area(
+            "✏️ Describe the issue or your goal (optional but recommended)", 
+            height=80, 
+            placeholder="e.g., 'My toaster won't turn on,' or 'How do I build a desk like this?'"
+        )
+    
+    with col2:
+        st.markdown("### Actions")
+        
+        # Get AI Guidance button - only enabled when image is ready
+        has_valid_image = (uploaded_image is not None or camera_image is not None) and st.session_state.app_state.get('upload_error') is None
+        
+        if st.button(
+            "🚀 Get AI Guidance", 
+            type="primary", 
+            use_container_width=True,
+            disabled=not has_valid_image
+        ):
+            image_to_analyze = None
+            
+            # Determine which image to use
+            if uploaded_image:
+                image_to_analyze, status = handle_uploaded_file(uploaded_image)
+            elif camera_image:
+                image_to_analyze, status = handle_uploaded_file(camera_image)
+            
+            if image_to_analyze is not None:
+                initial_analysis(image_to_analyze, context_text)
+                st.rerun()
+            else:
+                st.error(f"❌ Image processing failed: {status}")
+        
+        # Status message for button
+        if not has_valid_image:
+            if uploaded_image is None and camera_image is None:
+                st.warning("⚠️ Please upload an image first!")
+            elif st.session_state.app_state.get('upload_error'):
+                st.warning("⚠️ Fix upload error first!")
+        
+        # Troubleshooting section
+        with st.expander("🔧 Upload Troubleshooting"):
+            st.markdown("""
+            **Common fixes:**
+            1. **Refresh upload**: Click button below
+            2. **Check file size**: Max 5MB
+            3. **Try different format**: JPG works best
+            4. **Use camera**: If file upload fails
+            5. **Clear browser cache**: Ctrl+Shift+Delete
+            """)
+            
+            if st.button("🔄 Reset Upload", use_container_width=True):
+                st.session_state.app_state['upload_attempts'] = 0
+                st.session_state.app_state['upload_error'] = None
+                st.session_state.app_state['last_uploaded_file'] = None
+                st.rerun()
+            
+            # Debug info
+            if st.checkbox("Show debug info"):
+                st.json({
+                    "upload_attempts": st.session_state.app_state.get('upload_attempts', 0),
+                    "upload_error": st.session_state.app_state.get('upload_error'),
+                    "last_file": st.session_state.app_state.get('last_uploaded_file'),
+                    "has_uploaded_file": uploaded_image is not None,
+                    "has_camera_image": camera_image is not None
+                })
+        
+        if st.button("🔄 Start Over", use_container_width=True):
+            reset_state()
+else:
+    render_sidebar_navigation()
+    st.markdown("---")
+    st.markdown(f"### {st.session_state.app_state.get('project_title', 'Your Project')}")
+    st.markdown(f"**Category:** `{st.session_state.app_state.get('category', 'N/A')}`")
+    st.info(f"**Description:** {st.session_state.app_state.get('project_description', 'N/A')}")
+    st.markdown("---")
+
+    if not st.session_state.app_state['steps']:
+        if st.session_state.app_state['upcycling_options']:
+            st.markdown("#### The AI has suggested a few projects. Please choose one:")
+            for i, option in enumerate(st.session_state.app_state['upcycling_options']):
+                if st.button(option, key=f"option_{i}"):
+                    generate_detailed_guide_with_images(selected_option=option)
+                    st.rerun()
+        elif not st.session_state.app_state['plan_approved']:
+            st.markdown("#### The AI has proposed the following plan:")
+            st.success(st.session_state.app_state['initial_plan'])
+            if st.button("✅ Looks good, proceed with this plan", type="primary"):
+                st.session_state.app_state['plan_approved'] = True
+                generate_detailed_guide_with_images()
+                st.rerun()
+    else:
+        render_tools_list()
+        st.markdown("---")
+        current_step_index = st.session_state.app_state['current_step']
+        try:
+            step_num, step_text = st.session_state.app_state['steps'][current_step_index - 1]
+            render_step(step_num, step_text)
+        except IndexError:
+            st.session_state.app_state['current_step'] = 1
+            st.rerun()
+
+        total_steps = len(st.session_state.app_state['steps'])
+        done_count = sum(1 for d in st.session_state.app_state['done_flags'].values() if d)
+        if total_steps > 0:
+            progress = done_count / total_steps
+            st.progress(progress)
+            st.markdown(f"**Overall Progress:** {done_count} of {total_steps} completed ({progress:.0%})")
+            if done_count == total_steps:
+                st.balloons()
+                st.success("🎉 Congratulations! You've completed all steps!")
+
+    if st.button("🔄 Start Over"):
+        reset_state()