@learnpack/learnpack 5.0.362 → 5.0.363

package/src/creator/src/main.tsx

@@ -3,6 +3,7 @@ import { createRoot } from "react-dom/client"
 import { BrowserRouter, Route, Routes } from "react-router"
 import "./index.css"
 import App from "./App.tsx"
+import FileReadListener from "./components/FileReadListener.tsx"
 import SyllabusEditor from "./components/syllabus/SyllabusEditor.tsx"
 import { Toaster } from "react-hot-toast"
 import "./i18n"
@@ -13,6 +14,7 @@ createRoot(document.getElementById("root")!).render(
     <TooltipProvider>
       <Toaster />
       <BrowserRouter>
+        <FileReadListener />
         <Routes>
           <Route path="/creator" element={<App />} />
           <Route path="/creator/syllabus" element={<SyllabusEditor />} />

package/src/creator/src/utils/completionResult.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest";
 import {
   COMPLETION_ERROR_I18N_KEY,
+  getFailureGuidance,
   interpretCompletionPayload,
   TCompletionErrorCode,
 } from "./completionResult";
@@ -67,6 +68,19 @@ describe("interpretCompletionPayload", () => {
     ["Your team has used all available credits", "QUOTA_EXCEEDED"],
     ["monthly spending limit reached", "QUOTA_EXCEEDED"],
     ["Error code: 429 - rate limit exceeded", "RATE_LIMITED"],
+    [
+      "Error code: 400 - Unsupported value: 'temperature' does not support 0 with this model",
+      "REQUEST_REJECTED",
+    ],
+    [
+      "The selected model openai/gpt-5.6-luna doesn't support structured outputs",
+      "REQUEST_REJECTED",
+    ],
+    ["Error code: 401 - invalid api key", "REQUEST_REJECTED"],
+    [
+      "Error code: 404 - model not found, service unavailable",
+      "REQUEST_REJECTED",
+    ],
     ["Error code: 503 - service unavailable", "PROVIDER_UNAVAILABLE"],
     ["The request timed out", "PROVIDER_UNAVAILABLE"],
     ["Missing key description inside inputs dictionary", "UNKNOWN"],
@@ -86,6 +100,22 @@ describe("interpretCompletionPayload", () => {
     });
   });
 
+  it("keeps the job id as the reference for support", () => {
+    const result = interpretCompletionPayload(QUOTA_FAILURE);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reference).toBe("642271");
+  });
+
+  it("has no reference when the payload names no job", () => {
+    const result = interpretCompletionPayload(null);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reference).toBe("");
+  });
+
   it("treats a SUCCESS job without a list of steps as malformed", () => {
     const result = interpretCompletionPayload({
       status: "SUCCESS",
@@ -133,6 +163,37 @@ describe("interpretCompletionPayload", () => {
   });
 });
 
+describe("getFailureGuidance", () => {
+  it("offers a retry for a transient failure, however many there were", () => {
+    expect(getFailureGuidance("RATE_LIMITED", 5)).toEqual({
+      messageKey: "completionError.rateLimited",
+      canRetry: true,
+    });
+  });
+
+  it("points to support when the request cannot work", () => {
+    expect(getFailureGuidance("REQUEST_REJECTED", 1)).toEqual({
+      messageKey: "completionError.contactSupport",
+      canRetry: false,
+    });
+  });
+
+  it("gives an unknown failure one retry", () => {
+    expect(getFailureGuidance("UNKNOWN", 1).canRetry).toBe(true);
+    expect(getFailureGuidance("UNKNOWN", 2)).toEqual({
+      messageKey: "completionError.contactSupport",
+      canRetry: false,
+    });
+  });
+
+  it("keeps the quota message, which already explains what to do", () => {
+    expect(getFailureGuidance("QUOTA_EXCEEDED", 1)).toEqual({
+      messageKey: "completionError.quotaExceeded",
+      canRetry: false,
+    });
+  });
+});
+
 describe("COMPLETION_ERROR_I18N_KEY", () => {
   it("has a distinct key for every failure code", () => {
     const keys = Object.values(COMPLETION_ERROR_I18N_KEY);

package/src/creator/src/utils/completionResult.ts

@@ -16,6 +16,7 @@
 export type TCompletionErrorCode =
   | "QUOTA_EXCEEDED"
   | "RATE_LIMITED"
+  | "REQUEST_REJECTED"
   | "PROVIDER_UNAVAILABLE"
   | "MALFORMED_RESPONSE"
   | "TIMEOUT"
@@ -33,7 +34,21 @@ export type TSyllabusPayload = {
 
 export type TCompletionResult =
   | { ok: true; parsed: TSyllabusPayload }
-  | { ok: false; code: TCompletionErrorCode; detail: string };
+  | {
+      ok: false;
+      code: TCompletionErrorCode;
+      detail: string;
+      reference: string;
+    };
+
+/** A failed generation, as the error screen shows it. */
+export type TGenerationFailure = {
+  code: TCompletionErrorCode;
+  /** The completion job id, which support can look up. Empty if no job exists. */
+  reference: string;
+  /** Failures in a row, because repeating an unknown one stops being worth a retry. */
+  attempts: number;
+};
 
 /**
  * i18n key per failure code.
@@ -45,6 +60,7 @@ export type TCompletionResult =
 export const COMPLETION_ERROR_I18N_KEY: Record<TCompletionErrorCode, string> = {
   QUOTA_EXCEEDED: "completionError.quotaExceeded",
   RATE_LIMITED: "completionError.rateLimited",
+  REQUEST_REJECTED: "completionError.contactSupport",
   PROVIDER_UNAVAILABLE: "completionError.providerUnavailable",
   MALFORMED_RESPONSE: "completionError.malformedResponse",
   TIMEOUT: "completionError.timeout",
@@ -77,6 +93,15 @@ const classifyStatusText = (statusText: string): TCompletionErrorCode => {
     return "RATE_LIMITED";
   }
 
+  // The provider refused this request as written, so sending it again fails
+  // the same way. A 403 about credits already matched the quota case above.
+  if (
+    text.includes("doesn't support structured outputs") ||
+    /error code: (40[0134]|422)\b/.test(text)
+  ) {
+    return "REQUEST_REJECTED";
+  }
+
   if (
     text.includes("unavailable") ||
     text.includes("timeout") ||
@@ -89,9 +114,40 @@ const classifyStatusText = (statusText: string): TCompletionErrorCode => {
   return "UNKNOWN";
 };
 
+/**
+ * What to tell the user about a failure, and whether a retry can help.
+ *
+ * Offering a retry that cannot work only makes the user wait for the same
+ * error, so these failures point to support instead. An unknown failure gets
+ * one retry, since it may be transient.
+ * @param code - The failure to report.
+ * @param attempts - Failures in a row, including this one.
+ * @returns The i18n key of the message, and whether to offer a retry.
+ */
+export const getFailureGuidance = (
+  code: TCompletionErrorCode,
+  attempts: number
+): { messageKey: string; canRetry: boolean } => {
+  if (code === "QUOTA_EXCEEDED") {
+    return { messageKey: COMPLETION_ERROR_I18N_KEY[code], canRetry: false };
+  }
+
+  if (code === "REQUEST_REJECTED" || (code === "UNKNOWN" && attempts > 1)) {
+    return {
+      messageKey: COMPLETION_ERROR_I18N_KEY.REQUEST_REJECTED,
+      canRetry: false,
+    };
+  }
+
+  return { messageKey: COMPLETION_ERROR_I18N_KEY[code], canRetry: true };
+};
+
 const asString = (value: unknown): string =>
   typeof value === "string" ? value : "";
 
+const asReference = (value: unknown): string =>
+  typeof value === "number" || typeof value === "string" ? String(value) : "";
+
 const asStringArray = (value: unknown): string[] =>
   Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 
@@ -111,14 +167,16 @@ export function interpretCompletionPayload(
       ok: false,
       code: "MALFORMED_RESPONSE",
       detail: `Expected an object, received ${typeof payload}`,
+      reference: "",
     };
   }
 
   const job = payload as Record<string, unknown>;
+  const reference = asReference(job.id);
 
   if (job.status === "ERROR") {
     const detail = asString(job.status_text) || "No status text provided";
-    return { ok: false, code: classifyStatusText(detail), detail };
+    return { ok: false, code: classifyStatusText(detail), detail, reference };
   }
 
   const parsed = job.parsed;
@@ -135,6 +193,7 @@ export function interpretCompletionPayload(
       ok: false,
       code: "MALFORMED_RESPONSE",
       detail: "The completion carried no list of steps",
+      reference,
     };
   }
 

package/src/creator/src/utils/courseLanguage.test.ts

@@ -120,6 +120,12 @@ describe("detectSeedLanguage", () => {
     expect(detectSeedLanguage([es, es])).toBe("es");
   });
 
+  it("is not thrown off by the markdown of a PDF with tables", () => {
+    const read = `\n[Page 1]\n# **Mapa del curso**\n\n${es}\n\n|Campo|Valor|\n|---|---|\n|Idioma|[Español / inglés]|\n|Duración total|[Horas o semanas]|\n`;
+
+    expect(detectSeedLanguage([read])).toBe("es");
+  });
+
   it("reports sources that disagree instead of letting the longest win", () => {
     expect(detectSeedLanguage([en.repeat(10), es])).toBe("mixed");
   });

package/src/creator/src/utils/creationRequest.test.ts

@@ -1,31 +1,28 @@
 import { describe, it, expect } from "vitest";
 import type { ParsedFile } from "../components/FileUploader";
-import { buildCourseInfo, toCourseFormState } from "./creationRequest";
+import {
+  buildCourseInfo,
+  readFiles,
+  toCourseFormState,
+} from "./creationRequest";
 import useStore, { FormState } from "./store";
 
 /**
  * The courseInfo the wizard sent before the course language could be settled,
- * copied byte for byte from App.tsx (upstream 68c0bf9). Whitespace inside the
- * template is part of the prompt, so it must not be reformatted.
+ * copied from App.tsx (upstream 68c0bf9) without its technology list. Whitespace
+ * inside the template is part of the prompt, so it must not be reformatted.
  */
-const legacyCourseInfo = (
-  formState: FormState,
-  techs: { slug: string }[],
-  uploadedFiles: ParsedFile[]
-) =>
+const legacyCourseInfo = (formState: FormState, uploadedFiles: ParsedFile[]) =>
   // prettier-ignore
   `${JSON.stringify(
             formState
-          )}. The following technologies are available, choose up to 3 from the following list: <techs>${techs
-            .map((t) => t.slug)
-            .join(", ")}</techs>
-            
+          )}.
+
             The following files have been uploaded by the user: ${uploadedFiles.map((f) => `<FILE name="${f.name}">${f.text}</FILE>`).join("\n")}
             `;
 
 const defaultFormState = () => useStore.getInitialState().formState;
 
-const techs = [{ slug: "python" }, { slug: "sql" }];
 const uploadedFiles: ParsedFile[] = [
   {
     name: "notes.pdf",
@@ -35,7 +32,46 @@ const uploadedFiles: ParsedFile[] = [
   },
 ];
 
+describe("readFiles", () => {
+  it("keeps out files that are not read yet or failed", () => {
+    const files: ParsedFile[] = [
+      {
+        name: "ready.pdf",
+        text: "Text",
+        status: "SUCCESS",
+        notificationId: "1",
+      },
+      {
+        name: "reading.pdf",
+        text: "",
+        status: "PROCESSING",
+        notificationId: "2",
+      },
+      { name: "broken.pdf", text: "", status: "ERROR", notificationId: "3" },
+    ];
+
+    expect(readFiles(files).map((file) => file.name)).toEqual(["ready.pdf"]);
+  });
+});
+
 describe("buildCourseInfo", () => {
+  it("never sends an empty <FILE> for a file still being read", () => {
+    const courseInfo = buildCourseInfo({
+      formState: defaultFormState(),
+      uploadedFiles: [
+        {
+          name: "reading.pdf",
+          text: "",
+          status: "PROCESSING",
+          notificationId: "2",
+        },
+      ],
+      language: null,
+    });
+
+    expect(courseInfo).not.toContain("reading.pdf");
+  });
+
   it("sends exactly the previous prompt when no language is settled", () => {
     const formState = {
       ...defaultFormState(),
@@ -48,16 +84,15 @@ describe("buildCourseInfo", () => {
     const previousFormState = { ...formState };
     delete previousFormState.languageChosen;
 
-    expect(
-      buildCourseInfo({ formState, techs, uploadedFiles, language: null })
-    ).toBe(legacyCourseInfo(previousFormState, techs, uploadedFiles));
+    expect(buildCourseInfo({ formState, uploadedFiles, language: null })).toBe(
+      legacyCourseInfo(previousFormState, uploadedFiles)
+    );
   });
 
   it("asks for the settled language in plain words", () => {
     const formState = { ...defaultFormState(), language: "en" };
     const courseInfo = buildCourseInfo({
       formState,
-      techs,
       uploadedFiles,
       language: "es",
     });
@@ -79,7 +114,7 @@ describe("buildCourseInfo", () => {
     };
     for (const language of [null, "es"] as const) {
       expect(
-        buildCourseInfo({ formState, techs, uploadedFiles, language })
+        buildCourseInfo({ formState, uploadedFiles, language })
       ).not.toContain("languageChosen");
     }
   });

package/src/creator/src/utils/creationRequest.ts

@@ -7,6 +7,15 @@ const LANGUAGE_NAMES: Record<TCourseLanguage, string> = {
   es: "Spanish",
 };
 
+/**
+ * The files whose text is ready. One still being read has no text yet, and
+ * would reach the model as an empty document it cannot tell apart from a real one.
+ * @param files - The uploaded files.
+ * @returns Only the files read successfully.
+ */
+export const readFiles = (files: ParsedFile[]): ParsedFile[] =>
+  files.filter((file) => file.status === "SUCCESS");
+
 /**
  * Drops the wizard-only fields from the form state before it leaves the
  * wizard, in the prompt or in the syllabus sent to the server.
@@ -22,33 +31,29 @@ export const toCourseFormState = (formState: FormState): FormState => {
 /**
  * Builds the `courseInfo` text sent to the model to generate the syllabus.
  *
- * Without a settled language the text is exactly what the wizard sent before
- * the course language could be settled, so the model keeps choosing.
+ * Without a settled language the model keeps choosing it.
  * @param language - The course language settled before generation, or null.
  */
 export const buildCourseInfo = ({
   formState,
-  techs,
   uploadedFiles,
   language,
 }: {
   formState: FormState;
-  techs: { slug: string }[];
   uploadedFiles: ParsedFile[];
   language: TCourseLanguage | null;
 }): string => {
   const courseFormState = toCourseFormState(formState);
 
-  // Kept byte for byte from the original request, including the spaces on the
-  // blank line, which .editorconfig would trim. creationRequest.test.ts checks
-  // it against a copy of the original.
+  // Kept byte for byte, including the spaces on the blank line, which
+  // .editorconfig would trim. creationRequest.test.ts checks it against a copy.
   const courseInfo = `${JSON.stringify(
     language ? { ...courseFormState, language } : courseFormState
-  )}. The following technologies are available, choose up to 3 from the following list: <techs>${techs
-    .map((t) => t.slug)
-    .join(", ")}</techs>
-            
-            The following files have been uploaded by the user: ${uploadedFiles
+  )}.
+
+            The following files have been uploaded by the user: ${readFiles(
+              uploadedFiles
+            )
               .map((f) => `<FILE name="${f.name}">${f.text}</FILE>`)
               .join("\n")}
             `;

package/src/creator/src/utils/fileRead.ts

@@ -0,0 +1,60 @@
+import type { TFunction } from "i18next";
+import type { ParsedFile } from "../components/FileUploader";
+
+/**
+ * What the user should know about how a file was read.
+ * @param file - The uploaded file.
+ * @param t - The translation function.
+ * @returns One sentence per concern, empty when the read needs no comment.
+ */
+export const readNotices = (file: ParsedFile, t: TFunction): string[] => {
+  const { report } = file;
+  if (!report) return [];
+
+  const notices: string[] = [];
+
+  if (report.ai_pages.length > 0) {
+    notices.push(
+      t("uploader.files.aiReadNotice", {
+        read: report.ai_pages.length,
+        total: report.total_pages,
+      })
+    );
+  }
+
+  const missingPages = [
+    ...new Set([...report.unread_pages, ...report.failed_pages]),
+  ].sort((a, b) => a - b);
+
+  if (missingPages.length > 0) {
+    notices.push(
+      t("uploader.files.missingPagesNotice", {
+        pages: missingPages.join(", "),
+      })
+    );
+  }
+
+  return notices;
+};
+
+/**
+ * Turns rigobot's page markers into headings for reading. Display only: the
+ * model keeps receiving the markers.
+ * @param text - The text of the file, in markdown.
+ * @param t - The translation function.
+ * @returns The same text with a heading per page.
+ */
+export const withPageHeadings = (text: string, t: TFunction): string =>
+  text.replace(
+    /^\[Page (\d+)\]$/gm,
+    (_, page) => `\n\n#### ${t("uploader.files.reviewPage", { page })}\n\n`
+  );
+
+/**
+ * Whether the file's text uses markdown. Plain text must not go through the
+ * markdown renderer, which would join its lines into one paragraph.
+ * @param file - The uploaded file.
+ * @returns True when rigobot produced markdown for at least part of the file.
+ */
+export const isMarkdownRead = (file: ParsedFile): boolean =>
+  Boolean(file.report?.markdown || file.report?.ai_pages.length);

package/src/creator/src/utils/lib.ts

@@ -461,11 +461,6 @@ export const fixTitleLength = (title: string) => {
   return fixed;
 };
 
-export const getTechnologies = async () => {
-  const response = await axios.get(`/technologies`);
-  return response.data;
-};
-
 export const detectLanguage = (text: string) => {
   const lang = franc(text);
   if (lang === "spa") return "es";

package/src/creator/src/utils/store.ts

@@ -43,11 +43,6 @@ type Consumables = {
   [key: string]: number;
 };
 
-type TTechnology = {
-  slug: string;
-  lang: string;
-};
-
 type Store = {
   auth: Auth;
   formState: FormState;
@@ -65,8 +60,6 @@ type Store = {
   ) => void;
   cleanHistory: () => void;
   history: Syllabus[];
-  technologies: TTechnology[];
-  setTechnologies: (technologies: TTechnology[]) => void;
   undo: () => void;
   push: (syllabus: Syllabus) => void;
   cleanAll: () => void;
@@ -112,8 +105,6 @@ const useStore = create<Store>()(
         ],
       },
       messages: [],
-      technologies: [],
-      setTechnologies: (technologies: TTechnology[]) => set({ technologies }),
       setMessages: (
         messages: TMessage[] | ((prev: TMessage[]) => TMessage[])
       ) => {
@@ -178,7 +169,6 @@ const useStore = create<Store>()(
           uploadedFiles: [],
           messages: [],
           history: [],
-          technologies: [],
           formState: {
             description: "",
             duration: 0,