Merge pull request #20 from Code-the-Dream-School/SCRUM-29-backend-generate-summary-for-uploaded-resource

Scrum 29 backend generate summary for uploaded resource

Author: Ligo-code

backend/src/ai/llm.ts

@@ -1,9 +1,51 @@
-// backend/src/ai/llm.ts
+import type { GenerateContentResult } from "@google/generative-ai";
+
 export type GenerateTextParams = {
   prompt: string;
 };
 
-export const generateText = async ({ prompt }: GenerateTextParams): Promise<string> => {
+const MAX_RETRIES = 3;
+const INITIAL_RETRY_DELAY_MS = 1000;
+const TIMEOUT_MS = 30000;
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+const isRetryableError = (error: any): boolean => {
+  const message = error?.message?.toLowerCase() || "";
+  const status = error?.status || error?.statusCode || 0;
+
+  return (
+    status === 429 ||
+    status === 500 ||
+    status === 502 ||
+    status === 503 ||
+    status === 504 ||
+    message.includes("rate limit") ||
+    message.includes("timeout") ||
+    message.includes("network") ||
+    message.includes("econnreset") ||
+    message.includes("econnrefused")
+  );
+};
+
+const generateWithTimeout = async (
+  gemini: any,
+  prompt: string
+): Promise<GenerateContentResult> => {
+  return Promise.race([
+    gemini.generateContent({
+      contents: [{ role: "user", parts: [{ text: prompt }] }],
+    }),
+    new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("Request timeout")), TIMEOUT_MS)
+    ),
+  ]);
+};
+
+export const generateText = async ({
+  prompt,
+}: GenerateTextParams): Promise<string> => {
   const mode = (process.env.LLM_MODE || "stub").toLowerCase();
   console.log(`[llm] mode=${mode}`);
 
@@ -21,9 +63,6 @@ export const generateText = async ({ prompt }: GenerateTextParams): Promise<stri
   const { GoogleGenerativeAI } = await import("@google/generative-ai");
   const genAI = new GoogleGenerativeAI(apiKey);
 
-  // IMPORTANT:
-  // Do NOT force responseMimeType=application/json — it often truncates/cuts off output.
-  // We will enforce JSON via the prompt + backend parsing.
   const generationConfig: any = {
     temperature: 0,
     maxOutputTokens: 4096,
@@ -34,12 +73,43 @@ export const generateText = async ({ prompt }: GenerateTextParams): Promise<stri
     generationConfig,
   });
 
-  const result = await gemini.generateContent({
-    contents: [{ role: "user", parts: [{ text: prompt }] }],
-  });
+  let lastError: any;
+
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      const result = await generateWithTimeout(gemini, prompt);
+
+      const text = result.response.text() || "";
+      console.log(
+        `[llm] total attempts=${attempt + 1}, success=true, response chars=${
+          text.length
+        }`
+      );
+      console.log(
+        `[llm] response preview=${JSON.stringify(text.slice(0, 300))}`
+      );
+      return text;
+    } catch (error: any) {
+      lastError = error;
+      console.error(
+        `[llm] attempt ${attempt + 1}/${MAX_RETRIES} failed:`,
+        error.message
+      );
+
+      if (attempt < MAX_RETRIES - 1 && isRetryableError(error)) {
+        const delayMs = INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt);
+        console.log(`[llm] retrying in ${delayMs}ms...`);
+        await sleep(delayMs);
+      } else {
+        break;
+      }
+    }
+  }
 
-  const text = result.response.text() || "";
-  console.log(`[llm] response chars=${text.length}`);
-  console.log(`[llm] response preview=${JSON.stringify(text.slice(0, 300))}`);
-  return text;
+  console.error(`[llm] total attempts=${MAX_RETRIES}, success=false`);
+  throw new Error(
+    `Failed to generate text after ${MAX_RETRIES} attempts: ${
+      lastError?.message || "Unknown error"
+    }`
+  );
 };

backend/src/controllers/resourceController.ts

@@ -9,6 +9,7 @@ import {
   parseTags,
   normalizeText,
 } from "../utils/validation";
+import { generateSummaryFromText } from "../services/summaryGenerator";
 
 const requireUserObjectId = (
   req: Request,
@@ -265,3 +266,77 @@ export const deleteResource = async (
     next(error);
   }
 };
+
+export const generateSummary = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  try {
+    const ownerId = requireUserObjectId(req, res);
+    if (!ownerId) return;
+
+    const { id } = req.params;
+
+    const resource = await Resource.findOne({ _id: id, ownerId });
+
+    if (!resource) {
+      return res.status(404).json({
+        success: false,
+        error: "Resource not found",
+      });
+    }
+
+    try {
+      const summaryContent = await generateSummaryFromText(
+        resource.textContent
+      );
+
+      resource.summary = {
+        content: summaryContent,
+        createdAt: new Date(),
+      };
+
+      await resource.save();
+
+      return res.status(200).json({
+        success: true,
+        summary: resource.summary,
+      });
+    } catch (summaryError: any) {
+      if (summaryError instanceof Error) {
+        if (
+          summaryError.message.includes("too short") ||
+          summaryError.message.includes("too long") ||
+          summaryError.message.includes("required")
+        ) {
+          return res.status(400).json({
+            success: false,
+            error: summaryError.message,
+          });
+        }
+
+        if (summaryError.message.includes("GEMINI_API_KEY")) {
+          console.error("[resource] Gemini API key missing");
+          return res.status(500).json({
+            success: false,
+            error: "Summary service is not configured. Please contact support.",
+          });
+        }
+
+        return res.status(503).json({
+          success: false,
+          error: summaryError.message,
+        });
+      }
+
+      return res.status(500).json({
+        success: false,
+        error: "An unexpected error occurred while generating summary",
+      });
+    }
+  } catch (error: any) {
+    if (handleCastError(error, res)) return;
+    next(error);
+  }
+};

backend/src/routes/resourceRoutes.ts

@@ -5,19 +5,19 @@ import {
   getResourceById,
   updateResource,
   deleteResource,
+  generateSummary,
 } from "../controllers/resourceController";
 
 const router = express.Router();
 
-router
-  .route("/")
-  .get(getUserResources)
-  .post(createResource);
+router.route("/").get(getUserResources).post(createResource);
 
 router
   .route("/:id")
   .get(getResourceById)
   .patch(updateResource)
   .delete(deleteResource);
 
+router.post("/:id/summary", generateSummary);
+
 export default router;

backend/src/services/summaryGenerator.ts

@@ -0,0 +1,83 @@
+import { generateText } from "../ai/llm";
+import { LIMITS } from "../config/constants";
+
+const MAX_SUMMARY_CHARS = 5000;
+const MAX_INPUT_CHARS = LIMITS.TEXT_CONTENT_MAX_LENGTH;
+const MIN_INPUT_CHARS = 100;
+
+const SUMMARY_PROMPT = `
+You are a study assistant that creates concise summaries of educational content.
+
+Task: Create a clear, structured summary of the provided text.
+
+Formatting rules:
+- Plain text only (no Markdown, no code fences, no headings).
+- Use short paragraphs separated by line breaks.
+- Keep the summary under ${MAX_SUMMARY_CHARS} characters.
+- Focus on key concepts, main ideas, and important details.
+
+Quality rules:
+- Be accurate and comprehensive.
+- Maintain the original meaning and context.
+- Use clear, simple language suitable for studying.
+`.trim();
+
+export const generateSummaryFromText = async (
+  text: string
+): Promise<string> => {
+  const cleanedText = (text || "").trim();
+
+  if (!cleanedText) {
+    throw new Error("Text content is required for summary generation.");
+  }
+
+  if (cleanedText.length < MIN_INPUT_CHARS) {
+    throw new Error(
+      `Text is too short to generate a meaningful summary (minimum ${MIN_INPUT_CHARS} characters).`
+    );
+  }
+
+  if (cleanedText.length > MAX_INPUT_CHARS) {
+    throw new Error(
+      `Text is too long (maximum ${MAX_INPUT_CHARS} characters).`
+    );
+  }
+
+  const prompt = `
+${SUMMARY_PROMPT}
+
+Text to summarize:
+"""
+${cleanedText}
+"""
+
+Summary:
+`.trim();
+
+  try {
+    const raw = await generateText({ prompt });
+    const summary = raw?.trim() || "";
+
+    if (!summary) {
+      throw new Error("Failed to generate summary. Please try again.");
+    }
+
+    if (summary.length > MAX_SUMMARY_CHARS) {
+      const truncated = summary.slice(0, MAX_SUMMARY_CHARS);
+      const lastSpace = truncated.lastIndexOf(" ");
+      return lastSpace > 0 ? truncated.slice(0, lastSpace) : truncated;
+    }
+
+    return summary;
+  } catch (error) {
+    console.error("[summary] LLM generation failed:", error);
+
+    if (error instanceof Error && error.message.includes("GEMINI_API_KEY")) {
+      throw error;
+    }
+
+    throw new Error(
+      "Unable to generate summary at this time. Please try again later."
+    );
+  }
+};