Modified so that streamlit browser working fine

app/api/v1/audio.py

@@ -1,25 +1,27 @@
-# app/api/v1/audio.py
-from fastapi import APIRouter, HTTPException, Query, Depends, Request
+from fastapi import APIRouter, HTTPException, Depends, Body
 from pydantic import BaseModel
-from app.services.audio_service import generate_audio_file  # ✅ Only this import
+from app.services.audio_service import generate_audio_file
 from app.auth.auth import verify_token
-
+import uuid  # ✅ Add this
+import os    # ✅ Also needed
+from gtts import gTTS  # ✅ Needed if you're calling it directly here
 
 router = APIRouter()
 
-class AudioInput(BaseModel):
+class AudioRequest(BaseModel):
     text: str
     voice: str = "default"
     language: str = "en"
 
-@router.post("/generate", dependencies=[Depends(verify_token)])
-def generate_audio_endpoint(payload: AudioInput):
+@router.post("/generate")
+def generate_audio_endpoint(payload: AudioRequest):
     try:
-        file_path = generate_audio_file(payload.text, payload.voice, payload.language)
-
+        filename = f"audio_{uuid.uuid4().hex}.mp3"
+        file_path = f"generated_audio/{filename}"
+        os.makedirs("generated_audio", exist_ok=True)
+        tts = gTTS(text=payload.text, lang=payload.language)
+        tts.save(file_path)
         return {
-            "status": "success",
-            "type": "audio",
             "file_path": file_path,
             "download_url": f"/api/v1/download?file_path={file_path}"
         }

app/api/v1/download.py

@@ -1,24 +1,32 @@
-from fastapi import APIRouter, HTTPException, Query, Depends, Request
+from fastapi import APIRouter, HTTPException, Query
 from fastapi.responses import FileResponse
-from app.auth.auth import verify_token
 import os
 
 router = APIRouter()
 
-@router.get("/", dependencies=[Depends(verify_token)])
+@router.get("/")
 def download_file(file_path: str = Query(..., description="Relative path from project root")):
-    # Sanitize the input path
-    file_path = os.path.normpath(file_path)
-
-    # Absolute path (from project root)
-    abs_path = os.path.join(os.getcwd(), file_path)
-    
-    print("Looking for file at:", abs_path)
-    if not os.path.isfile(abs_path):
+    print(f"🔍 Requested file path: {file_path}")
+
+    # Sanitize and resolve absolute path
+    full_path = os.path.abspath(file_path)
+
+    # Ensure file is inside your allowed folder (to prevent directory traversal)
+    allowed_root = os.path.abspath("generated")
+    if not full_path.startswith(allowed_root):
+        raise HTTPException(status_code=400, detail="Invalid file path")
+
+    print(f"📂 Resolved full path: {full_path}")
+
+    if not os.path.isfile(full_path):
+        print("❌ File not found.")
         raise HTTPException(status_code=404, detail="File not found")
 
+    # Set correct media type dynamically (you can refine this later)
+    media_type = "audio/mpeg" if full_path.endswith(".mp3") else "image/png"
+
     return FileResponse(
-        path=abs_path,
-        filename=os.path.basename(abs_path),
-        media_type='application/octet-stream'
+        full_path,
+        media_type=media_type,
+        filename=os.path.basename(full_path)
     )

app/api/v1/image.py

@@ -1,19 +1,54 @@
-from fastapi import APIRouter, HTTPException, Query, Depends, Request
+from fastapi import APIRouter, HTTPException, Depends, Body
 from pydantic import BaseModel
-from app.services.image_service import generate_image_file
 from app.auth.auth import verify_token
+from PIL import Image, ImageDraw, ImageFont
+from datetime import datetime
+import os
 
 router = APIRouter()
 
-class ImageInput(BaseModel):
+class ImageRequest(BaseModel):
     prompt: str
     style: str = "default"
 
-@router.post("/generate", dependencies=[Depends(verify_token)])  # ✅ FIX: POST, not GET
-def generate_image(payload: ImageInput):
-    filename = generate_image_file(payload.prompt, payload.style)
-    return {
-        "message": "Image generated successfully",
-        "filename": filename,
-        "download_url": f"/api/v1/download?file_path=generated/image/{filename}"
-    }
+class ImageResponse(BaseModel):
+    message: str
+    filename: str
+    download_url: str
+
+@router.post("/generate", response_model=ImageResponse)
+def generate_image_file_endpoint(
+    data: ImageRequest = Body(...),
+    token: str = Depends(verify_token)
+):
+    prompt = data.prompt
+    style = data.style
+    filename = f"image_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+    folder = "generated/image"
+    os.makedirs(folder, exist_ok=True)
+    output_path = os.path.join(folder, filename)
+
+    try:
+        img = Image.new("RGB", (768, 512), color="white")
+        draw = ImageDraw.Draw(img)
+
+        try:
+            font = ImageFont.truetype("arial.ttf", 20)
+        except:
+            font = ImageFont.load_default()
+
+        draw.text((20, 20), f"Prompt: {prompt}", fill="black", font=font)
+        draw.text((20, 60), f"Style: {style}", fill="gray", font=font)
+
+        img.save(output_path, format="PNG")
+
+        print(f"✅ Image created: {output_path}, size = {os.path.getsize(output_path)} bytes")
+        return {
+            "message": "Image generated successfully",
+            "filename": filename,
+            "download_url": f"/api/v1/download?file_path=generated/image/{filename}"
+        }
+
+    except Exception as e:
+        print(f"❌ Image generation failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

app/api/v1/ppt.py

@@ -14,7 +14,7 @@ class Slide(BaseModel):
 class PPTInput(BaseModel):
     slides: List[Slide]
 
-@router.post("/generate", dependencies=[Depends(verify_token)])
+@router.post("/generate")
 def generate_ppt(payload: PPTInput):
     filename = generate_ppt_file([slide.dict() for slide in payload.slides])
     return {

app/api/v1/video.py

@@ -1,20 +1,37 @@
-from fastapi import APIRouter, HTTPException, Query, Depends, Request
+# app/api/v1/video.py
+from fastapi import APIRouter, HTTPException, Depends, Body
 from pydantic import BaseModel
 from app.services.video_service import generate_video_file
 from app.auth.auth import verify_token
-
+import uuid  # ✅ Add this
+import os    # ✅ Also needed
+from gtts import gTTS  # ✅ Needed if you're calling it directly here
+from typing import Optional
 
 router = APIRouter()
 
 class VideoInput(BaseModel):
-    script: str
-    duration: int = 10
+    prompt: str
+    tone: str
+    domain: str
+    environment: str
+    transcript: Optional[str] = None  # ✅ make optional
 
-@router.post("/generate", dependencies=[Depends(verify_token)])  # ✅ FIX: POST, not GET
-def generate_video(payload: VideoInput):
-    filename = generate_video_file(payload.script, payload.duration)
-    return {
-        "message": "Video generated successfully",
-        "filename": filename,
-        "download_url": f"/api/v1/download?file_path=generated/video/{filename}"
-    }
+@router.post("/generate")
+def generate_video_endpoint(
+    payload: VideoInput = Body(...), 
+    token: str = Depends(verify_token)):
+    try:
+        # Use `payload.prompt` as the script
+        filename = generate_video_file(
+            script=payload.prompt,  # 👈 mapping prompt to script
+            duration=10  # Or dynamically set based on text length
+        )
+        return {
+            "message": "Video generated successfully",
+            "filename": filename,
+            "download_url": f"/api/v1/download?file_path=generated/video/{filename}"
+        }
+    except Exception as e:
+        print("❌ Video generation error:", str(e))
+        raise HTTPException(status_code=500, detail=str(e))

app/auth/auth.py

@@ -1,32 +1,25 @@
-from fastapi import Request, HTTPException, status
-from fastapi import Depends, HTTPException, status
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+#from fastapi import Depends, HTTPException, status
+from fastapi import HTTPException, Security
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from starlette.status import HTTP_403_FORBIDDEN
 
+from fastapi import Security
+from fastapi.security import HTTPBearer
 
-# Replace with a more secure method later (e.g., from .env)
-API_TOKEN = "my_secure_token_123"  # we can generate a random one using uuid or secrets
+bearer_scheme = HTTPBearer()
 
-def verify_token(request: Request):
-    token = request.headers.get("Authorization")
-    if not token or token.replace("Bearer ", "") != API_TOKEN:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid or missing token",
-        )
-    return request
+#security = HTTPBearer()
 
-security = HTTPBearer()
+from fastapi import Header, HTTPException, Depends
 
-VALID_TOKENS = {"token123", "mysecuretoken"}  # Your valid tokens
+VALID_TOKENS = ["my_secure_token_123"]  # or load from file/db/env
 
-def auth_required(
-    credentials: HTTPAuthorizationCredentials = Depends(security),
-):
+def verify_token(credentials: HTTPAuthorizationCredentials = Security(bearer_scheme)):
     token = credentials.credentials
-    if token not in VALID_TOKENS:
+    # Replace with your actual logic (static check shown here)
+    if token != "my_secure_token_123":
         raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid or missing token"
+            status_code=HTTP_403_FORBIDDEN,
+            detail="Invalid or expired token"
         )
-    return token
 

app/main.py

@@ -1,8 +1,39 @@
 # app/main.py
+from fastapi import FastAPI, Depends
+from fastapi.security import HTTPBearer
+from fastapi import Security
+
 from fastapi import FastAPI
 
-app = FastAPI()
+from app.api.v1.audio import router as audio_router
+from app.api.v1.video import router as video_router
+from app.api.v1.image import router as image_router
+from app.api.v1.ppt import router as ppt_router
+from app.api.v1.metrics import router as metrics_router
+from app.api.v1.download import router as download_router
+from fastapi import Security
+
+from app.auth.auth import verify_token
+
+bearer_scheme = HTTPBearer()
+
 
+app = FastAPI(
+    title="Media Generation API",
+    description="Generate audio, video, image, and PPT content via secure endpoints.",
+    version="1.0.0"
+)
+
+# Root for health check
 @app.get("/")
 def root():
-    return {"message": "FastAPI on Fly.io!"}
+    return {"message": "FastAPI running successfully!"}
+
+# Registering route modules
+app.include_router(audio_router, prefix="/api/v1/audio", tags=["Audio"], dependencies=[Depends(verify_token)])
+app.include_router(video_router, prefix="/api/v1/video", tags=["Video"], dependencies=[Depends(verify_token)])
+app.include_router(image_router, prefix="/api/v1/image", tags=["Image"], dependencies=[Depends(verify_token)])
+app.include_router(ppt_router, prefix="/api/v1/ppt", tags=["PPT"], dependencies=[Depends(verify_token)])
+app.include_router(metrics_router, prefix="/api/v1/metrics", tags=["Metrics"], dependencies=[Depends(verify_token)])
+app.include_router(download_router, prefix="/api/v1/download", tags=["Download"])
+

app/services/audio_service.py

@@ -6,6 +6,7 @@ from app.db import SessionLocal
 from app.models import MediaGeneration
 import logging
 logger = logging.getLogger(__name__)
+import uuid
 
 def generate_audio_file(text: str, voice: str = "default", language: str = "en") -> str:
     try:

app/services/image_service.py

@@ -18,6 +18,10 @@ def generate_image_file(prompt: str, style: str = "default") -> str:
         with open(os.path.join(folder, filename), "w") as f:
             f.write(f"Prompt: {prompt}\nStyle: {style}")
         logger.info(f"Generated Image: {filename}")
+        if os.path.isfile(output_path):
+            print(f"✅ Image created: {output_path}, size = {os.path.getsize(output_path)} bytes")
+        else:
+            print(f"❌ Image file not found at: {output_path}")
         return filename
     except:
         logger.error(f"Image Geneartion failed: {str(e)}")

app/services/video_service - Copy.py

@@ -0,0 +1,35 @@
+# app/services/video_service.py
+import os
+from datetime import datetime
+from app.db import SessionLocal
+from app.models import MediaGeneration
+import logging
+logger = logging.getLogger(__name__)
+
+def generate_video_file(script: str, duration: int = 10) -> str:
+    try:
+        # Simulate saving a generated video file
+        filename = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        folder = "generated/video"
+        os.makedirs(folder, exist_ok=True)
+    
+        # Placeholder: Simulate video generation by writing script info to a file
+        with open(os.path.join(folder, filename), "w") as f:
+            f.write(f"Script: {script}\nDuration: {duration} seconds")
+        logger.info(f"Generated Video: {filename}")
+        return filename
+    except:
+        logger.error(f"Video generation failed: {str(e)}")
+        raise
+    
+
+def save_metadata(media_type, prompt, file_path):
+    db = SessionLocal()
+    record = MediaGeneration(
+        media_type=media_type,
+        prompt=prompt,
+        file_path=file_path,
+    )
+    db.add(record)
+    db.commit()
+    db.close()

app/services/video_service.py

@@ -1,35 +1,67 @@
 # app/services/video_service.py
+
+import cv2
+import numpy as np
 import os
-from datetime import datetime
-from app.db import SessionLocal
-from app.models import MediaGeneration
-import logging
-logger = logging.getLogger(__name__)
+import uuid
+import math
+from gtts import gTTS
+from mutagen.mp3 import MP3
+import subprocess
+
+def generate_video_file(script: str, duration: int = None) -> str:
+    # Paths
+    audio_filename = f"generated/audio/audio_{uuid.uuid4().hex}.mp3"
+    raw_video_path = f"generated/video/video_{uuid.uuid4().hex}.mp4"
+    final_video_path = raw_video_path.replace(".mp4", "_final.mp4")
+
+    # Ensure directories exist
+    os.makedirs(os.path.dirname(audio_filename), exist_ok=True)
+    os.makedirs(os.path.dirname(raw_video_path), exist_ok=True)
+
+    # Generate audio
+    tts = gTTS(text=script, lang='en')
+    tts.save(audio_filename)
+
+    # Get accurate audio duration
+    audio = MP3(audio_filename)
+    audio_duration = audio.info.length  # e.g., 5.98 seconds
+
+    # Video specs
+    fps = 25  # Higher FPS = smoother video
+    total_frames = int(audio_duration * fps)
+    width, height = 640, 480
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(raw_video_path, fourcc, fps, (width, height))
+
+    # Create each frame
+    for _ in range(total_frames):
+        frame = np.ones((height, width, 3), dtype=np.uint8) * 255
+        cv2.putText(frame, script, (30, height // 2), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 2)
+        out.write(frame)
+
+    out.release()
+
+    # Merge audio and video
+    ffmpeg_cmd = [
+        "ffmpeg",
+        "-y",
+        "-i", raw_video_path,
+        "-i", audio_filename,
+        "-c:v", "libx264",
+        "-c:a", "aac",
+        "-crf", "23",
+        "-c:a", "aac",
+        "-b:a", "128k",
+        "-shortest",        
+        "-movflags", "+faststart",  # 👈 crucial for browser playback
+        final_video_path
+    ]
 
-def generate_video_file(script: str, duration: int = 10) -> str:
     try:
-        # Simulate saving a generated video file
-        filename = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-        folder = "generated/video"
-        os.makedirs(folder, exist_ok=True)
-    
-        # Placeholder: Simulate video generation by writing script info to a file
-        with open(os.path.join(folder, filename), "w") as f:
-            f.write(f"Script: {script}\nDuration: {duration} seconds")
-        logger.info(f"Generated Video: {filename}")
-        return filename
-    except:
-        logger.error(f"Video generation failed: {str(e)}")
-        raise
-    
-
-def save_metadata(media_type, prompt, file_path):
-    db = SessionLocal()
-    record = MediaGeneration(
-        media_type=media_type,
-        prompt=prompt,
-        file_path=file_path,
-    )
-    db.add(record)
-    db.commit()
-    db.close()
+        subprocess.run(ffmpeg_cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"FFmpeg failed: {e}")
+        return None
+
+    return os.path.basename(final_video_path)

generated_audio/audio_12aa4a7f8c6b4e459e88fd7bfa8559fe.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:343053419eba6ee94bd9d7fd54631336e97b693dea9775f2d57c6f342953cefb
+size 9024

generated_audio/audio_2084def7399c47fc81f1ea75a2bb38df.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:343053419eba6ee94bd9d7fd54631336e97b693dea9775f2d57c6f342953cefb
+size 9024

generated_audio/audio_4d6439239f3b4099b1e6fde8a9331613.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6924a2184a3a139ef4d6d9bc5e1e08d3b1b69d7e6904f8acb458d40cbc90fc73
+size 9024

generated_audio/audio_785571d23e8c401886fbe9b176071973.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1b9c225a86625e285d88be0b465bdb82177e21876fb7bedce63c313e018f343
+size 47808

generated_audio/audio_8a8be69edd134341afc83be9d200f5c2.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:343053419eba6ee94bd9d7fd54631336e97b693dea9775f2d57c6f342953cefb
+size 9024

generated_audio/audio_b3d3a162a45941579686e8bee223032e.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6924a2184a3a139ef4d6d9bc5e1e08d3b1b69d7e6904f8acb458d40cbc90fc73
+size 9024

generated_audio/audio_ddccc5c34f7840bdb838254e343c7b14.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:343053419eba6ee94bd9d7fd54631336e97b693dea9775f2d57c6f342953cefb
+size 9024

streamlit_ui.py

@@ -1,9 +1,12 @@
 # streamlit_ui.py
+
 import streamlit as st
 import requests
 import base64
+from PIL import Image
+import io
+import os
 import tempfile
-from backend.subtitle_utils import generate_srt_from_text, enhance_video_with_subtitles_and_bgm
 
 st.set_page_config(
     page_title="Prompta - Text to Media Generator",
@@ -13,40 +16,95 @@ st.set_page_config(
 )
 st.title("🎙️🖼️🎞️ Prompta - Text to Media Generator")
 
-#API_BASE = "http://localhost:8000"
-API_BASE = "https://2255d6a4793d.ngrok-free.app"
+# 🛠️ Get Token FIRST
+TOKEN = st.sidebar.text_input("🔑 API Token", type="password")
+HEADERS = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else {}
+
+# ✅ Display AFTER token is typed
+if TOKEN:
+    st.sidebar.write("Using token:", TOKEN)
+    st.sidebar.write("Sending headers:", HEADERS)
+else:
+    st.sidebar.warning("⚠️ Please enter a valid API token to use the app.")
+
+API_BASE = "http://localhost:8000"
+
 
-def render_media(file_bytes, media_type, label):
+
+API_BASE = "http://localhost:8000"
+#API_BASE = "https://2255d6a4793d.ngrok-free.app"
+
+def render_media(file_bytes, media_type, caption):
     b64 = base64.b64encode(file_bytes).decode()
     if media_type == "audio":
         st.audio(f"data:audio/wav;base64,{b64}", format="audio/wav")
     elif media_type == "video":
         st.video(f"data:video/mp4;base64,{b64}")
     elif media_type == "image":
-        st.image(file_bytes, caption=label, use_column_width=True)
+        try:
+            # Validate if it's a valid image
+            img = Image.open(io.BytesIO(file_bytes))
+            st.image(img, caption=caption)
+        except Exception as e:
+            st.warning("⚠️ Cannot render image. It may be corrupt or empty.")
+            st.code(str(e))
 
 st.sidebar.header("🛠️ Settings")
-TOKEN = st.sidebar.text_input("🔑 API Token", type="password")
-HEADERS = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else {}
+#TOKEN = st.sidebar.text_input("🔑 API Token", type="password")
+#HEADERS = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else {}
+
+voice = st.selectbox("Choose voice", ["en", "hi", "te", "ta"])
+voice_map = {
+    "en": "en-US",
+    "hi": "hi-IN",
+    "te": "te-IN",
+    "ta": "ta-IN"
+}
 
 tab = st.sidebar.radio("Select Task", ["Text to Audio", "Text to Image", "Text to Video"])
 
 if tab == "Text to Audio":
     st.subheader("🎤 Text to Audio")
     text = st.text_area("Enter text")
-    voice = st.selectbox("Choose voice/language", ["en-US", "hi-IN", "te-IN", "ta-IN"])
+    voice = st.selectbox("Choose language", ["English", "Hindi", "Telugu", "Tamil"])
+    voice_map = {
+        "English": ("en-US", "en"),
+        "Hindi": ("hi-IN", "hi"),
+        "Telugu": ("te-IN", "te"),
+        "Tamil": ("ta-IN", "ta")
+    }
+    voice_code, lang_code = voice_map[voice]
 
     if st.button("🔊 Generate Audio"):
         with st.spinner("Generating audio..."):
-            r = requests.post(f"{API_BASE}/audio/generate", json={"text": text, "voice": voice}, headers=HEADERS)
+            r = requests.post(
+                f"{API_BASE}/api/v1/audio/generate", 
+                json={
+                    "text": text,
+                    "voice": voice_code,
+                    "language": lang_code
+                },
+                headers=HEADERS
+            )
             if r.status_code == 200:
-                data = r.json()
-                download_url = f"{API_BASE}{data['download_url']}"
-                audio_resp = requests.get(download_url, headers=HEADERS)
-                if audio_resp.status_code == 200:
-                    render_media(audio_resp.content, "audio", "Generated Audio")
-                else:
-                    st.error("❌ Failed to download audio file.")
+                try:
+                    data = r.json()
+                    st.code(data, language="json")  # Debug: show full JSON response in UI
+
+                    if "download_url" in data:
+                        download_url = f"{API_BASE}{data['download_url']}"
+                        audio_resp = requests.get(download_url, headers=HEADERS)
+                        if audio_resp.status_code == 200:
+                            render_media(audio_resp.content, "audio", "Generated Audio")
+                        else:
+                            st.error("❌ Failed to download audio file.")
+                    else:
+                        st.error("❌ `download_url` not found in API response.")
+                        st.code(data)
+                except Exception as e:
+                    st.error("❌ Failed to parse API response.")
+                    st.code(r.text)
+                    st.exception(e)
             else:
                 st.error(f"❌ Failed: {r.json().get('detail')}")
 
@@ -54,15 +112,41 @@ if tab == "Text to Audio":
 elif tab == "Text to Image":
     st.subheader("🖼️ Text to Image")
     prompt = st.text_area("Enter image prompt")
-    model = st.selectbox("Choose model", ["sdxl", "deepfloyd", "kandinsky"])
+    style = st.selectbox("Choose Style", ["sdxl", "deepfloyd", "kandinsky"])
 
     if st.button("🧠 Generate Image"):
         with st.spinner("Generating image..."):
-            r = requests.post(f"{API_BASE}/image/generate", json={"prompt": prompt, "model": model}, headers=HEADERS)
+            r = requests.post(
+                f"{API_BASE}/api/v1/image/generate", 
+                json={"prompt": prompt, "style": style},  # ✅ correct key
+                headers=HEADERS
+            )
             if r.status_code == 200:
-                render_media(r.content, "image", "Generated Image")
+                try:
+                    res_json = r.json()
+                    download_url = res_json.get("download_url")
+                    if not download_url:
+                        st.error("No download URL returned.")
+                    else:
+                        download_full_url = f"{API_BASE}{download_url}"
+                        image_response = requests.get(download_full_url, headers={"accept": "image/png"}, allow_redirects=True)
+                        if image_response.status_code != 200:
+                            st.error("❌ Failed to download image.")
+                            st.code(image_response.text)
+                            st.write("Status:", image_response.status_code)
+                            st.write("Headers:", image_response.headers)
+                        st.write(image_response.status_code, image_response.headers)
+                        render_media(image_response.content, "image", "Generated Image")
+                except Exception as e:
+                    st.error(f"⚠️ Failed to fetch/display image: {str(e)}")
+                    st.code(r.text)
             else:
-                st.error(f"❌ Failed: {r.json().get('detail')}")
+                try:
+                    detail = r.json().get("detail")
+                except Exception:
+                    detail = r.text  # fallback to raw response text (may be empty or HTML)
+
+                st.error(f"❌ Failed: {detail}")                
 
 elif tab == "Text to Video":
     st.subheader("🎞️ Text to Video")
@@ -77,32 +161,55 @@ elif tab == "Text to Video":
     if st.button("🎬 Generate Video"):
         with st.spinner("Generating video..."):
             r = requests.post(
-                f"{API_BASE}/video/generate",
+                f"{API_BASE}/api/v1/video/generate",
                 json={"prompt": prompt, "tone": tone, "domain": domain, "environment": environment},
                 headers=HEADERS
             )
             if r.status_code == 200:
-                video_bytes = r.content
-                if enhance and transcript:
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_vid:
-                        tmp_vid.write(video_bytes)
-                        tmp_vid_path = tmp_vid.name
-
-                    srt_path = generate_srt_from_text(transcript, output_path="streamlit_subs.srt")
-                    enhanced_path = "streamlit_final_video.mp4"
-                    enhance_video_with_subtitles_and_bgm(
-                        video_path=tmp_vid_path,
-                        srt_path=srt_path,
-                        bgm_path="default_bgm.mp3",
-                        output_path=enhanced_path
-                    )
-
-                    with open(enhanced_path, "rb") as f:
-                        render_media(f.read(), "video", "Enhanced Video")
-                else:
-                    render_media(video_bytes, "video", "Generated Video")
+                try:
+                    data = r.json()
+                    st.code(data, language="json")
+
+                    download_url = data.get("download_url")
+                    if not download_url:
+                        st.error("⚠️ No download URL received.")
+                    else:
+                        full_video_url = f"{API_BASE}{download_url}"
+                        video_response = requests.get(full_video_url, headers=HEADERS)
+                        if video_response.status_code == 200:
+                            video_bytes = video_response.content
+                            st.write("📦 Video size (bytes):", len(video_bytes))
+
+                            if enhance and transcript:
+                                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_vid:
+                                    tmp_vid.write(video_bytes)
+                                    tmp_vid_path = tmp_vid.name
+
+                                srt_path = generate_srt_from_text(transcript, output_path="streamlit_subs.srt")
+                                enhanced_path = "streamlit_final_video.mp4"
+                                enhance_video_with_subtitles_and_bgm(
+                                    video_path=tmp_vid_path,
+                                    srt_path=srt_path,
+                                    bgm_path="default_bgm.mp3",
+                                    output_path=enhanced_path
+                                )
+
+                                with open(enhanced_path, "rb") as f:
+                                    render_media(f.read(), "video", "Enhanced Video")
+                            else:
+                                st.video(video_bytes)
+                        else:
+                            st.error("❌ Failed to download video.")
+                except Exception as e:
+                    st.error("❌ Error parsing response or rendering video.")
+                    st.code(r.text)
+                    st.exception(e)
             else:
-                st.error(f"❌ Failed: {r.json().get('detail')}")
+                try:
+                    st.error(f"❌ Failed: {r.json().get('detail')}")
+                except:
+                    st.error(f"❌ Failed: {r.text}")
+
 
 st.sidebar.markdown("---")
 st.sidebar.info("Built with ❤️ for AI GovTech Challenge 2025")