Update app.py

app.py

@@ -1,30 +1,23 @@
 ###############################################################################
-# app.py – AI Report & Slides Demo (stable 2025-06-23)
+# app.py  –  streamlined & stable
 ###############################################################################
 import os, re, json, uuid, tempfile, asyncio, base64, io, hashlib
 from pathlib import Path
-
-import streamlit as st
-import pandas as pd
-import matplotlib
-matplotlib.use("Agg")
+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
-
+try: from markdown_it import MarkdownIt
+except ImportError: MarkdownIt = None
 from pptx import Presentation
 from pptx.util import Inches, Pt
 
-# ── Google APIs ──────────────────────────────────────────────────────────────
+# Google APIs
 from google.oauth2.service_account import Credentials
 from googleapiclient.discovery import build
 
-# ── Gemini & ADK ─────────────────────────────────────────────────────────────
+# Gemini / ADK
 from google import genai
 from google.genai import types
 from google.adk.agents   import LlmAgent, SequentialAgent
@@ -33,283 +26,235 @@ from google.adk.sessions import InMemorySessionService
 from langchain_experimental.agents import create_pandas_dataframe_agent
 from langchain_google_genai       import ChatGoogleGenerativeAI
 
-###############################################################################
-# 1. Constants & env
-###############################################################################
-FONT_DIR   = Path(__file__).parent
-FONT_NAME  = "NotoSans"
-FONT_REG   = FONT_DIR / "NotoSans-Regular.ttf"
-FONT_BOLD  = FONT_DIR / "NotoSans-Bold.ttf"
-
-SLIDES      = 7
-TTS_MODEL   = "gemini-2.5-flash-preview-tts"
-CREDS_JSON  = os.getenv("GOOGLE_SERVICE_ACCOUNT_JSON")          # optional
+# ─────────────────────────────────────────────────────────────────────────────
+# CONFIG
+# ─────────────────────────────────────────────────────────────────────────────
+FONT_DIR = Path(__file__).parent
+FONT_REG = FONT_DIR / "NotoSans-Regular.ttf"
+FONT_BLD = FONT_DIR / "NotoSans-Bold.ttf"
+FONT_NAME = "NotoSans"
+SLIDE_COUNT = 7
+TTS_MODEL  = "gemini-2.5-flash-preview-tts"
+CREDS_JSON = os.getenv("GOOGLE_SERVICE_ACCOUNT_JSON")   # optional
 
 os.environ["STREAMLIT_CONFIG_DIR"] = tempfile.gettempdir()
 os.environ["MPLCONFIGDIR"]         = tempfile.gettempdir()
 
-###############################################################################
-# 2. Utility helpers (all cached where heavy)
-###############################################################################
-def _hash_df(df: pd.DataFrame) -> str:
+API_KEY = os.getenv("GEMINI_API_KEY")
+if not API_KEY: st.error("Set GEMINI_API_KEY"); st.stop()
+GEMINI = genai.Client(api_key=API_KEY)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SMALL HELPERS
+# ─────────────────────────────────────────────────────────────────────────────
+fix_bullets = lambda txt: txt.replace("\x95", "•")
+
+def hash_df(df: pd.DataFrame) -> str:
     return hashlib.sha1(pd.util.hash_pandas_object(df, index=True).values).hexdigest()
 
+def pcm_to_wav(raw: bytes, rate=24_000):
+    import wave, contextlib, io as _io
+    buf=_io.BytesIO()
+    with contextlib.closing(wave.open(buf, "wb")) as f:
+        f.setnchannels(1); f.setsampwidth(2); f.setframerate(rate); f.writeframes(raw)
+    return buf.getvalue()
+
+# ─────────────────────────────────────────────────────────────────────────────
+#   CACHED BUILDERS
+# ─────────────────────────────────────────────────────────────────────────────
 @st.cache_resource(show_spinner=False)
-def get_pandas_agent(df_hash: str, api_key: str):
+def pandas_agent(df_hash: str):
     return create_pandas_dataframe_agent(
-        llm=ChatGoogleGenerativeAI(model="gemini-2.0-flash",
-                                   google_api_key=api_key),
+        llm=ChatGoogleGenerativeAI(model="gemini-2.0-flash", google_api_key=API_KEY),
         df=st.session_state.df,
-        verbose=False,
-        allow_dangerous_code=True)
-
-def fix_bullets(text: str) -> str:
-    """Convert stray Win-1252 bullet (0x95) → proper Unicode bullet."""
-    return text.replace("\x95", "•")
-
-def generate_tts_audio(client, text):
-    text = (text[:500] + "...") if len(text) > 500 else text
-    try:
-        resp = client.models.generate_content(
-            model=TTS_MODEL,
-            contents=f"Say clearly: {text}",
-            config=types.GenerateContentConfig(
-                response_modalities=["AUDIO"],
-                speech_config=types.SpeechConfig(
-                    voice_config=types.VoiceConfig(
-                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
-                            voice_name="Kore")))))
-        audio = resp.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
-
-def pcm_to_wav(raw: bytes, rate=24000, width=2):
-    import wave, contextlib
-    buf = io.BytesIO()
-    with contextlib.closing(wave.open(buf, "wb")) as wf:
-        wf.setnchannels(1); wf.setsampwidth(width); wf.setframerate(rate); wf.writeframes(raw)
-    return buf.getvalue()
+        verbose=False, allow_dangerous_code=True)
 
 @st.cache_resource(show_spinner=False)
-def build_charts(chart_descs: tuple, df_hash: str, api_key: str):
-    """Return {desc:str → path:str} for unique chart descriptions."""
-    agent = get_pandas_agent(df_hash, api_key)
-    desc2path = {}
-    for desc in chart_descs:
-        if desc in desc2path: continue
-        agent.run(f"Create a {desc} using matplotlib")
-        fig = plt.gcf()
-        p = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.png"
-        fig.savefig(p, dpi=300, bbox_inches="tight"); plt.close()
-        desc2path[desc] = str(p)
-    return desc2path
+def build_charts(descs: tuple, df_hash: str):
+    agent = pandas_agent(df_hash)
+    out={}
+    for d in descs:
+        if d in out: continue
+        agent.run(f"Create a {d} using matplotlib"); fig=plt.gcf()
+        p=Path(tempfile.gettempdir())/f"{uuid.uuid4()}.png"
+        fig.savefig(p,dpi=300,bbox_inches="tight"); plt.close()
+        out[d]=str(p)
+    return out
 
 @st.cache_resource(show_spinner=False)
-def build_pdf(markdown_src: str) -> bytes:
-    """Return final PDF bytes with fonts, charts, tables fixed."""
-    markdown_src = fix_bullets(markdown_src)
-    # 1 Markdown → HTML
-    html = (MarkdownIt("commonmark", {"breaks": True}).enable("table").render(markdown_src)
-            if MarkdownIt else
-            markdown(markdown_src, extensions=["tables"]))
-    # 2 Dummy pdf for metrics
-    tmp = FPDF(); w_mm, px = tmp.w - 2*tmp.l_margin, lambda mm: int(mm*tmp.k)
-    # 3 Tables
-    html = re.sub(r'(<table[^>]*>)', r'\1<font size="8">', html)\
-           .replace('</table>', '</font></table>')
-    html = re.sub(r'<table(?![^>]*\bwidth=)', lambda m: f'<table width="{px(w_mm)}"', html)
-    # 4 Scale imgs
-    html = re.sub(r'<img\s+src="([^"]+\.png)"\s*/?>',
-                  lambda m: f'<img src="{m.group(1)}" width="{int(w_mm)}" />', html)
-    # 5 PDF build
-    class PDF(FPDF, HTMLMixin): pass
-    pdf = PDF(); pdf.set_auto_page_break(auto=True, margin=15)
-    for style, path in [("",FONT_REG), ("B",FONT_BOLD), ("I",FONT_REG), ("BI",FONT_BOLD)]:
-        pdf.add_font(FONT_NAME, style, str(path), uni=True)
-    pdf.set_fallback_fonts([FONT_NAME])
-    pdf.add_page(); pdf.set_font(FONT_NAME, "B", 18)
-    pdf.cell(0, 12, "AI-Generated Business Report", ln=True); pdf.ln(4)
-    pdf.set_font(FONT_NAME, "", 11); pdf.write_html(html)
+def build_pdf(html_ready_md: str) -> bytes:
+    html_ready_md = fix_bullets(html_ready_md)
+    html = (MarkdownIt("commonmark",{"breaks":True}).enable("table").render(html_ready_md)
+            if MarkdownIt else markdown(html_ready_md,extensions=["tables"]))
+    dummy=FPDF(); page_w=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(page_w)}"',html)
+    html=re.sub(r'<img[^>]+src="([^"]+\.png)"[^>]*>',
+                lambda m:f'<img src="{m.group(1)}" width="{int(page_w)}" />',html)
+    class PDF(FPDF,HTMLMixin): pass
+    pdf=PDF(); pdf.set_auto_page_break(True,15)
+    for s,p in [("",FONT_REG),("B",FONT_BLD),("I",FONT_REG),("BI",FONT_BLD)]:
+        pdf.add_font(FONT_NAME,s,str(p),uni=True)
+    pdf.set_fallback_fonts([FONT_NAME]); pdf.add_page()
+    pdf.set_font(FONT_NAME,"B",18); pdf.cell(0,12,"AI-Generated Business Report",ln=True); pdf.ln(3)
+    pdf.set_font(FONT_NAME,"",11); pdf.write_html(html)
     return bytes(pdf.output(dest="S"))
 
 @st.cache_resource(show_spinner=False)
-def build_pptx(slide_texts: tuple, desc2path: dict) -> Path:
-    prs = Presentation(); blank = prs.slide_layouts[6]
-    for i, txt in enumerate(slide_texts):
-        txt = fix_bullets(txt)
-        slide = prs.slides.add_slide(blank)
-        slide.shapes.add_textbox(Inches(0.6), Inches(0.4), Inches(9), Inches(0.8))\
-             .text_frame.text = f"Slide {i+1}"
-        body = slide.shapes.add_textbox(Inches(0.6), Inches(1.4), Inches(9), Inches(3.2))
-        body.text_frame.text = re.sub(r'<.*?>', '', txt)
-        m = re.search(r'<generate_chart:\s*"([^"]+)"\s*>', txt)
-        if m and m.group(1) in desc2path:
-            slide.shapes.add_picture(desc2path[m.group(1)],
-                                     Inches(1), Inches(3.7), width=Inches(8))
-    out = Path(tempfile.gettempdir()) / f"slides_{uuid.uuid4().hex}.pptx"
-    prs.save(out); return out
+def build_pptx(slide_texts: tuple, desc2png: dict) -> bytes:
+    prs=Presentation(); layout=prs.slide_layouts[1]      # title+content
+    for idx,raw in enumerate(slide_texts):
+        raw=fix_bullets(raw); plain=re.sub(r'<.*?>','',raw).strip()
+        title_line, *body_lines = plain.splitlines()
+        body_lines=[l.strip().lstrip('*').strip() for l in body_lines if l.strip()]
+        slide=prs.slides.add_slide(layout)
+        slide.shapes.title.text=title_line
+        tf=slide.shapes.placeholders[1].text_frame
+        tf.clear()
+        for l in body_lines:
+            p=tf.add_paragraph(); p.text=l; p.font.size=Pt(18); p.level=0
+        m=re.search(r'<generate_chart:\s*"([^"]+)"\s*>', raw)
+        if m and m.group(1) in desc2png:
+            slide.shapes.add_picture(desc2png[m.group(1)], Inches(1), Inches(4), width=Inches(8))
+    fout=io.BytesIO(); prs.save(fout); return fout.getvalue()
 
-def upload_to_slides(pptx_path: Path) -> str | None:
-    if not CREDS_JSON:
-        st.warning("Service-account JSON not configured; skipping Slides upload.")
-        return None
-    creds = Credentials.from_service_account_file(
+@st.cache_resource(show_spinner=False)
+def upload_pptx_to_slides(pptx_bytes: bytes) -> str|None:
+    if not CREDS_JSON: return None
+    creds=Credentials.from_service_account_file(
         CREDS_JSON,
         scopes=["https://www.googleapis.com/auth/drive.file",
                 "https://www.googleapis.com/auth/presentations"])
-    drive = build("drive",  "v3", credentials=creds)
-    meta  = {"name": f"AI-Slides-{uuid.uuid4().hex[:6]}",
-             "mimeType": "application/vnd.google-apps.presentation"}
-    media = {"mimeType": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-             "body": open(pptx_path, "rb")}
-    f = drive.files().create(body=meta, media_body=media).execute()
+    drv=build("drive","v3",credentials=creds)
+    meta={"name":f"AI-Slides‐{uuid.uuid4().hex[:6]}",
+          "mimeType":"application/vnd.google-apps.presentation"}
+    media={"body":io.BytesIO(pptx_bytes),
+           "mimeType":"application/vnd.openxmlformats-officedocument.presentationml.presentation"}
+    f=drv.files().create(body=meta,media_body=media).execute()
     return f"https://docs.google.com/presentation/d/{f['id']}"
 
-###############################################################################
-# 3. Streamlit UI
-###############################################################################
-st.set_page_config(page_title="AI Report & Slides", layout="wide")
-st.title("📊 AI-Generated Report & Presentation")
-
-API_KEY = os.getenv("GEMINI_API_KEY")
-if not API_KEY:
-    st.error("Set `GEMINI_API_KEY` in env."); st.stop()
-client = genai.Client(api_key=API_KEY)
-
-mode = st.radio("Output:", ["Report", "Presentation", "Both"], horizontal=True)
-uploaded = st.file_uploader("Upload CSV / XLSX", ["csv", "xlsx"])
-user_ctx = st.text_area("Optional business context / objectives")
-run_btn = st.button("🚀 Generate")
-
-###############################################################################
-# 4. Main pipeline
-###############################################################################
-if run_btn:
-    if not uploaded: st.warning("Please upload a dataset."); st.stop()
-    # 4.1 Load
-    try:
-        df = pd.read_excel(uploaded) if uploaded.name.lower().endswith(".xlsx") else pd.read_csv(uploaded)
-    except Exception as e:
-        st.error(f"Read error: {e}"); st.stop()
-    st.session_state.df = df
-    df_hash = _hash_df(df)
-
-    # 4.2 Agents
-    report_agent = LlmAgent(
-        name="ReportAgent", model="gemini-2.5-flash",
-        instruction=("You are a senior business analyst. Write an executive-level Markdown "
-                     "report with <generate_chart: \"...\"> placeholders."))
-
-    pres_agent = LlmAgent(
-        name="PresentationAgent", model="gemini-2.5-flash",
-        instruction=(f"Create exactly {SLIDES} slides. Each slide starts with 'Slide X:' "
-                     "and may include <generate_chart: \"...\"> tags."))
-
-    subs = []
-    if mode in ("Report", "Both"): subs.append(report_agent)
-    if mode in ("Presentation", "Both"): subs.append(pres_agent)
-    pipeline = SequentialAgent(name="Pipeline", sub_agents=subs)
-
-    # 4.3 Context → Gemini
-    ctx = {"dataset_info": {"shape": df.shape,
-                            "columns": list(df.columns),
-                            "dtypes": df.dtypes.astype(str).to_dict(),
-                            "missing": df.isna().sum().to_dict()},
-           "user_context": user_ctx,
-           "preview": df.head().to_dict()}
-
-    # 4.4 Run ADK
-    svc, sid = InMemorySessionService(), str(uuid.uuid4())
-    asyncio.run(svc.create_session(app_name="app", user_id="user", session_id=sid))
-    runner = Runner(agent=pipeline, app_name="app", session_service=svc)
-
-    final = {}
-    async def _collect():
-        async for ev in runner.run_async(
-                user_id="user", session_id=sid,
-                new_message=types.Content(role="user",
-                                          parts=[types.Part(text=json.dumps(ctx))])):
-            if ev.is_final_response():
-                final[ev.author] = ev.content.parts[0].text
-    asyncio.run(_collect())
-
-    # 4.5 Charts
-    chart_tags = re.findall(r'<generate_chart:\s*"([^"]+)"\s*>', "\n".join(final.values()))
-    desc2path = build_charts(tuple(chart_tags), df_hash, API_KEY)
-
-    # 4.6 Tabs
-    if mode == "Both":
-        tab_report, tab_pres = st.tabs(["📄 Report", "📑 Presentation"])
-    else:
-        tab_report = tab_pres = st
-
-    #######################################################################
-    # Report
-    #######################################################################
-    if mode in ("Report", "Both"):
-        md = fix_bullets(final["ReportAgent"])
-        # Replace tags: base-64 for preview + file path for PDF
-        preview_md = md; pdf_md = md
-        for d,pth in desc2path.items():
-            with open(pth, "rb") as f:
-                b64 = base64.b64encode(f.read()).decode()
-            embed = f'<img src="data:image/png;base64,{b64}" style="max-width:100%;margin:8px 0;" />'
-            preview_md = re.sub(rf'<generate_chart:\s*"{re.escape(d)}"\s*>', embed, preview_md)
-            pdf_md     = re.sub(rf'<generate_chart:\s*"{re.escape(d)}"\s*>',
-                                f'<img src="{pth}" />', pdf_md)
-
-        with tab_report:
-            st.markdown("### Report Preview")
-            st.markdown(preview_md, unsafe_allow_html=True)
-            st.download_button("⬇️ Download PDF",
-                               build_pdf(pdf_md),
-                               "business_report.pdf",
-                               mime="application/pdf")
-
-    #######################################################################
-    # Presentation
-    #######################################################################
-    if mode in ("Presentation", "Both"):
-        raw = fix_bullets(final["PresentationAgent"])
-        slides_txt = [s.strip() for s in re.split(r'\bSlide\s+\d+:', raw) if s.strip()][:SLIDES]
-        st.session_state.slides = slides_txt
-        st.session_state.curr   = 0
-
-        def render(idx: int):
-            txt = st.session_state.slides[idx]
-            st.markdown(f"#### Slide {idx+1} / {len(slides_txt)}")
-            st.write(txt)
-            if st.button("🔊 Narrate", key=f"tts_{idx}"):
-                with st.spinner("TTS…"):
-                    aud,mime = generate_tts_audio(client, txt)
-                    if aud:
-                        if 'pcm' in mime or 'L16' in mime:
-                            st.audio(pcm_to_wav(aud), format="audio/wav")
-                        else:
-                            st.audio(aud, format=mime)
-
-        with tab_pres:
-            col1,col2 = st.columns(2)
-            if col1.button("⬅️ Back", disabled=st.session_state.curr==0):
-                st.session_state.curr -= 1
-            if col2.button("Next ➡️",
-                           disabled=st.session_state.curr==len(slides_txt)-1):
-                st.session_state.curr += 1
-            render(st.session_state.curr)
-
-            # PPTX build (cached)
-            pptx = build_pptx(tuple(slides_txt), desc2path)
-            st.download_button("⬇️ Download PPTX",
-                               pptx.read_bytes(),
-                               "presentation.pptx",
-                               mime=("application/vnd.openxmlformats-officedocument."
-                                     "presentationml.presentation"))
-            if st.button("⬆️ Upload to Google Slides"):
-                url = upload_to_slides(pptx)
-                if url:
-                    st.success(f"[Open Slides]({url})")
+# ─────────────────────────────────────────────────────────────────────────────
+#   UI : INPUTS
+# ─────────────────────────────────────────────────────────────────────────────
+mode = st.radio("Output:", ["Report","Presentation","Both"],horizontal=True)
+file  = st.file_uploader("CSV / XLSX",["csv","xlsx"])
+context = st.text_area("Optional business context / goals")
+if not st.button("🚀 Generate"): st.stop()
+if not file: st.warning("Upload data first"); st.stop()
+
+# ─────────────────────────────────────────────────────────────────────────────
+#   LOAD DATAFRAME
+# ─────────────────────────────────────────────────────────────────────────────
+try:
+    st.session_state.df = pd.read_excel(file) if file.name.lower().endswith(".xlsx") else pd.read_csv(file)
+except Exception as e:
+    st.error(f"Failed to read file: {e}"); st.stop()
+df_hash = hash_df(st.session_state.df)
+st.success(f"Loaded {st.session_state.df.shape[0]} rows × {st.session_state.df.shape[1]} cols")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#   BUILD & RUN AGENTS
+# ─────────────────────────────────────────────────────────────────────────────
+subs=[]
+if mode in ("Report","Both"):
+    subs.append(LlmAgent(name="ReportAgent",model="gemini-2.5-flash",
+        instruction="Write an exec-level Markdown report, using <generate_chart:\"…\"> placeholders."))
+if mode in ("Presentation","Both"):
+    subs.append(LlmAgent(name="PresentationAgent",model="gemini-2.5-flash",
+        instruction=f"Create {SLIDE_COUNT} slides. Each begins 'Slide X:' and may include <generate_chart:\"…\"> placeholders."))
+
+root=SequentialAgent(name="Pipeline",sub_agents=subs)
+svc=InMemorySessionService(); session_id=str(uuid.uuid4())
+asyncio.run(svc.create_session(app_name="app",user_id="usr",session_id=session_id))
+runner=Runner(agent=root,app_name="app",session_service=svc)
+
+ctx = {"dataset_info":{"shape": st.session_state.df.shape,
+                       "columns": list(st.session_state.df.columns),
+                       "dtypes": st.session_state.df.dtypes.astype(str).to_dict(),
+                       "missing": st.session_state.df.isna().sum().to_dict()},
+       "user_context": context,
+       "preview": st.session_state.df.head().to_dict()}
+
+final={}
+async def _run():
+    async for ev in runner.run_async(user_id="usr",session_id=session_id,
+                                     new_message=types.Content(role="user",
+                                                               parts=[types.Part(text=json.dumps(ctx))])):
+        if ev.is_final_response(): final[ev.author]=ev.content.parts[0].text
+asyncio.run(_run())
+
+# ─────────────────────────────────────────────────────────────────────────────
+#   CHARTS (one build for everything)
+# ─────────────────────────────────────────────────────────────────────────────
+all_md = "\n".join(final.values())
+chart_descs = re.findall(r'<generate_chart:\s*"([^"]+)"\s*>', all_md)
+png_map = build_charts(tuple(chart_descs), df_hash)
+
+# ─────────────────────────────────────────────────────────────────────────────
+#   TABS
+# ─────────────────────────────────────────────────────────────────────────────
+if mode=="Both":
+    t_report,t_pres=st.tabs(["📄 Report","📑 Slides"])
+else:
+    t_report=t_pres=st
+
+# ─────────────────────────────────────────────────────────────────────────────
+#   REPORT
+# ─────────────────────────────────────────────────────────────────────────────
+if mode in ("Report","Both"):
+    md_raw = fix_bullets(final["ReportAgent"])
+    md_prev=md_raw; md_pdf=md_raw
+    for d,p in png_map.items():
+        b64=base64.b64encode(open(p,"rb").read()).decode()
+        md_prev=re.sub(rf'<generate_chart:\s*"{re.escape(d)}"\s*>',
+                       f'<img src="data:image/png;base64,{b64}" style="max-width:100%;margin:6px 0;" />',
+                       md_prev)
+        md_pdf =re.sub(rf'<generate_chart:\s*"{re.escape(d)}"\s*>',
+                       f'<img src="{p}" />',md_pdf)
+    with t_report:
+        st.markdown(md_prev,unsafe_allow_html=True)
+        if "pdf_bytes" not in st.session_state:
+            st.session_state.pdf_bytes=build_pdf(md_pdf)
+        st.download_button("⬇️ Download PDF", st.session_state.pdf_bytes,
+                           "business_report.pdf","application/pdf")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#   PRESENTATION
+# ─────────────────────────────────────────────────────────────────────────────
+if mode in ("Presentation","Both"):
+    raw = fix_bullets(final["PresentationAgent"])
+    slides=[s.strip() for s in re.split(r'\bSlide\s+\d+:',raw) if s.strip()][:SLIDE_COUNT]
+    st.session_state.slides=slides
+    if "pptx_bytes" not in st.session_state:
+        st.session_state.pptx_bytes=build_pptx(tuple(slides), png_map)
+
+    if "idx" not in st.session_state: st.session_state.idx=0
+
+    def show_slide(i):
+        txt=slides[i]; st.markdown(f"### Slide {i+1}/{len(slides)}"); st.write(txt)
+        if st.button("🔊 Speak",key=f"tts{i}"):
+            with st.spinner("Generating TTS…"):
+                aud,mime=generate_tts_audio(GEMINI,txt)
+                if aud:
+                    st.audio(pcm_to_wav(aud) if 'pcm' in mime or 'L16' in mime else aud,
+                             format="audio/wav" if 'pcm' in mime or 'L16' in mime else mime)
+
+    with t_pres:
+        c1,c2=st.columns(2)
+        c1.button("⬅️",disabled=st.session_state.idx==0,
+                  on_click=lambda: st.session_state.__setitem__("idx",st.session_state.idx-1))
+        c2.button("➡️",disabled=st.session_state.idx==len(slides)-1,
+                  on_click=lambda: st.session_state.__setitem__("idx",st.session_state.idx+1))
+        show_slide(st.session_state.idx)
+
+        st.download_button("⬇️ PPTX", st.session_state.pptx_bytes,
+                           "presentation.pptx",
+                           ("application/vnd.openxmlformats-officedocument."
+                            "presentationml.presentation"))
+        if st.button("⬆️ Upload to Google Slides"):
+            with st.spinner("Uploading…"):
+                url=upload_pptx_to_slides(st.session_state.pptx_bytes)
+            url and st.success(f"[Open Slides]({url})")
 ###############################################################################
 # End
 ###############################################################################