Update generateStoryLines.ts

src/app/server/actions/generateStoryLines.ts

@@ -1,51 +1,160 @@
-"use server"
+"use server";
 
-import { Story, StoryLine, TTSVoice } from "@/types"
+import "server-only";
+import type { TTSVoice, StoryLine } from "@/types";
 
-const instance = `${process.env.AI_STORY_API_GRADIO_URL || ""}`
-const secretToken = `${process.env.AI_STORY_API_SECRET_TOKEN || ""}`
+const BASE = (process.env.AI_STORY_API_GRADIO_URL || "").replace(/\/+$/, "");
+const SECRET = process.env.AI_STORY_API_SECRET_TOKEN || "";
+const DEBUG = (process.env.DEBUG_STORY_API || "").toLowerCase() === "true";
+const FN_INDEX = Number(process.env.AI_STORY_API_FN_INDEX ?? 0); // default 0
+
+function assertEnv() {
+  if (!BASE) throw new Error("Missing AI_STORY_API_GRADIO_URL");
+  if (!SECRET) throw new Error("Missing AI_STORY_API_SECRET_TOKEN");
+}
+
+function logInfo(...args: any[]) {
+  // Always log compact request summary
+  console.log("[story-api]", ...args);
+}
+function logDebug(...args: any[]) {
+  if (DEBUG) console.debug("[story-api:debug]", ...args);
+}
+function logError(...args: any[]) {
+  console.error("[story-api:error]", ...args);
+}
+
+function abbreviate(s: string, n = 200): string {
+  if (s == null) return String(s);
+  return s.length > n ? s.slice(0, n) + "…" : s;
+}
+
+function safePromptPreview(p: string) {
+  const cropped = (p || "").slice(0, 60).replace(/\s+/g, " ").trim();
+  return `${cropped}${cropped.length < (p || "").length ? "…" : ""}`;
+}
+
+function withTimeout<T>(p: Promise<T>, ms = 90_000) {
+  return Promise.race<T>([
+    p,
+    new Promise<T>((_, rej) =>
+      setTimeout(() => rej(new Error(`Request timed out after ${ms} ms`)), ms)
+    ) as Promise<T>,
+  ]);
+}
+
+async function timedFetch(url: string, init: RequestInit) {
+  const t0 = Date.now();
+  const res = await withTimeout(fetch(url, init));
+  const ms = Date.now() - t0;
+  return { res, ms };
+}
+
+async function postPredict(body: any) {
+  const headers = { "Content-Type": "application/json", Accept: "application/json" };
+  const endpoints = [`${BASE}/api/predict`, `${BASE}/run/predict`];
+
+  let lastErr: Error | null = null;
+
+  for (const url of endpoints) {
+    try {
+      logDebug("POST", url, "body:", abbreviate(JSON.stringify(body), 300));
+      const { res, ms } = await timedFetch(
+        url,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          cache: "no-store",
+          // keepalive: true, // optional
+        }
+      );
+
+      const text = await res.text();
+      let json: any = null;
+      try {
+        json = text ? JSON.parse(text) : null;
+      } catch {
+        // non-JSON (HTML cold start page? proxy error?), keep raw text for logs
+      }
+
+      if (res.ok) {
+        logInfo(`OK ${res.status} in ${ms}ms @ ${url}`);
+        logDebug("response json:", abbreviate(JSON.stringify(json), 500));
+        return json;
+      }
+
+      // Surface meaningful backend errors (token, queue, NSFW, validation, etc.)
+      const detail =
+        json?.detail ??
+        json?.error ??
+        json?.message ??
+        text ??
+        "(empty body)";
+      const message = `HTTP ${res.status} ${res.statusText} @ ${url} in ${ms}ms — ${abbreviate(
+        String(detail),
+        1200
+      )}`;
+      logError(message);
+      lastErr = new Error(message);
+    } catch (e: any) {
+      const msg = `${url} network error: ${e?.message || e}`;
+      logError(msg);
+      lastErr = new Error(msg);
+    }
+  }
+
+  throw lastErr || new Error("All predict endpoints failed");
+}
 
 export async function generateStoryLines(prompt: string, voice: TTSVoice): Promise<StoryLine[]> {
-  if (!prompt?.length) {
-    throw new Error(`prompt is too short!`)
+  assertEnv();
+
+  if (!prompt || prompt.trim().length < 4) {
+    throw new Error("Prompt is too short.");
   }
 
-  const cropped = prompt.slice(0, 30)
-  console.log(`user requested "${cropped}${cropped !== prompt ? "..." : ""}"`)
-
-  // positivePrompt = filterOutBadWords(positivePrompt)
-
-  const res = await fetch(instance + (instance.endsWith("/") ? "" : "/") + "api/predict", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      // Authorization: `Bearer ${token}`,
-    },
-    body: JSON.stringify({
-      fn_index: 0, // <- important!
-      data: [
-        secretToken,
-        prompt,
-        voice,
-      ],
-    }),
-    cache: "no-store",
-    // we can also use this (see https://vercel.com/blog/vercel-cache-api-nextjs-cache)
-    // next: { revalidate: 1 }
-  })
-
-
-  const rawJson = await res.json()
-  const data = rawJson.data as StoryLine[][]
-
-  const stories = data?.[0] || []
-
-  if (res.status !== 200) {
-    throw new Error('Failed to fetch data')
+  // (Optional) lightweight prompt policy guard; adjust/remove per your policy
+  // const banned = /(sexual|sexy|porn|nsfw|explicit)/i;
+  // if (banned.test(prompt)) {
+  //   throw new Error("This demo does not support explicit content. Please try a different prompt.");
+  // }
+
+  logInfo(`user requested "${safePromptPreview(prompt)}"`, `(voice=${voice})`);
+
+  const body = {
+    fn_index: FN_INDEX, // must match your Space's endpoint index
+    data: [SECRET, prompt, voice],
+  };
+
+  const json = await postPredict(body);
+
+  // Gradio payloads are typically { data: [...] }
+  const data = json?.data;
+  if (!Array.isArray(data)) {
+    const s = abbreviate(JSON.stringify(json), 1000);
+    logError("Unexpected response shape:", s);
+    throw new Error(`Unexpected response shape from backend: ${s}`);
   }
 
-  return stories.map(line => ({
-    text: line.text.replaceAll(" .", ".").replaceAll(" ?", "?").replaceAll(" !", "!").trim(),
-    audio: line.audio
-  }))
-}
+  // Your Python backend returns an array in data[0], each item {text, audio}
+  const lines = (data[0] as StoryLine[]) || [];
+  if (!Array.isArray(lines)) {
+    const s = abbreviate(JSON.stringify(data[0]), 600);
+    logError("Unexpected payload in data[0]:", s);
+    throw new Error(`Unexpected payload in data[0]: ${s}`);
+  }
+
+  const cleaned: StoryLine[] = lines.map((l) => ({
+    text: (l.text || "")
+      .replaceAll(" .", ".")
+      .replaceAll(" ,", ",")
+      .replaceAll(" !", "!")
+      .replaceAll(" ?", "?")
+      .trim(),
+    audio: l.audio,
+  }));
+
+  logDebug(`returned ${cleaned.length} lines`);
+  return cleaned;
+}