scribe-cms 0.0.14 → 0.0.15

package/dist/index.js

@@ -2827,6 +2827,13 @@ function buildOutputFormatLine(hasFrontmatter, slugStrategy) {
   }
   return slugStrategy === "localized" ? "`frontmatter` (object with translated frontmatter fields), `body` (string, full MDX body), `slug` (string)." : "`frontmatter` (object), `body` (string).";
 }
+function buildRetryContextSection(previousError) {
+  return [
+    "",
+    "## Previous attempt",
+    `A previous attempt at this translation was rejected with the following validation errors: ${previousError}. Produce a corrected translation that fixes these issues while re-checking every schema constraint (required fields, array minimums, maximum lengths).`
+  ];
+}
 function buildPageTranslationPrompt(input) {
   const localeName = LOCALE_NAMES[input.targetLocale] ?? input.targetLocale;
   const localizationPrompt = input.resolved.promptOverride ?? defaultLocalizationPrompt(localeName, input.targetLocale);
@@ -2857,7 +2864,10 @@ function buildPageTranslationPrompt(input) {
     buildOutputFormatLine(
       Object.keys(input.translatableFrontmatter).length > 0,
       input.slugStrategy
-    )
+    ),
+    // Retry context is locale-specific suffix material: it MUST stay after the
+    // EN body so the cacheable prefix is byte-identical with and without it.
+    ...input.previousError ? buildRetryContextSection(input.previousError) : []
   ];
   return [...prefix, ...suffix].join("\n");
 }
@@ -3072,7 +3082,8 @@ function prepareTranslation(config, item, options, startedAt) {
     contextLabel: resolveContextLabel(enDoc, item.enSlug),
     translatableFrontmatter: payload.frontmatter,
     enBody: payload.body,
-    slugStrategy: type.slugStrategy
+    slugStrategy: type.slugStrategy,
+    previousError: item.previousError
   });
   const responseSchema = buildGeminiResponseSchema(type.schema, type.slugStrategy);
   return {
@@ -3484,6 +3495,82 @@ async function runPool(items, concurrency, worker) {
 function labelForItem(item) {
   return `${item.contentType}/${item.enSlug}@${item.locale}`;
 }
+function buildRetryWorklist(failed, originalByKey) {
+  return failed.map((result) => {
+    const key = translationItemKey(result);
+    const original = originalByKey.get(key);
+    return {
+      contentType: result.contentType,
+      enSlug: result.enSlug,
+      locale: result.locale,
+      reason: original?.reason ?? "missing",
+      currentEnHash: original?.currentEnHash ?? "",
+      storedEnHash: original?.storedEnHash,
+      previousError: result.error ?? "Translation failed"
+    };
+  });
+}
+async function runRetryRound(config, retryItems, options) {
+  const startedAt = Date.now();
+  const translateOne = options.translateOne ?? ((item) => translatePage(config, item, { model: options.model, force: true }));
+  if (options.mode === "direct") {
+    const active = /* @__PURE__ */ new Set();
+    await runPool(retryItems, options.concurrency, async (item) => {
+      const label = labelForItem(item);
+      active.add(label);
+      options.onProgress?.({ type: "item-start", item, active: [...active] });
+      const result = await translateOne(item);
+      active.delete(label);
+      options.onResult(result);
+    });
+    return;
+  }
+  const entries = [];
+  for (const item of retryItems) {
+    const itemStartedAt = Date.now();
+    try {
+      const outcome = prepareTranslation(config, item, { model: options.model, force: true }, itemStartedAt);
+      if (outcome.status === "done") {
+        options.onResult(outcome.result);
+      } else {
+        entries.push({
+          apiModel: resolveGeminiModelId(displayModelFor(outcome.prepared)),
+          prompt: outcome.prepared.prompt,
+          prepared: outcome.prepared
+        });
+      }
+    } catch (error) {
+      options.onResult(failedResultForItem(item, error, itemStartedAt));
+    }
+  }
+  const plans = planBatchJobs(entries);
+  const submitted = await Promise.all(
+    plans.map(async (plan, planIndex) => {
+      try {
+        return await submitBatchJobPlan(config, {
+          plan,
+          displayModel: normalizeGeminiDisplayName(plan.apiModel),
+          jobIndex: planIndex,
+          jobCount: plans.length,
+          onProgress: options.onProgress
+        });
+      } catch (error) {
+        for (const entry of plan.entries) {
+          options.onResult(failedResultForItem(entry.prepared.item, error, startedAt));
+        }
+        return void 0;
+      }
+    })
+  );
+  const jobsToPoll = submitted.filter((row) => row !== void 0);
+  if (jobsToPoll.length > 0) {
+    await pollAndIngestBatchJobs(config, jobsToPoll, {
+      jobCount: jobsToPoll.length,
+      onProgress: options.onProgress,
+      onResult: options.onResult
+    });
+  }
+}
 async function translatePage(config, item, options = {}) {
   const startedAt = Date.now();
   let outcome;
@@ -3656,9 +3743,40 @@ async function translateWorklist(config, items, options = {}) {
       });
     }
   }
-  const results = collector.assemble();
+  const mainResults = collector.assemble();
+  const failed = mainResults.filter((result) => result.failed);
+  if (failed.length === 0) {
+    const totals2 = summarizeResults(mainResults, Date.now() - startedAt);
+    options.onProgress?.({ type: "done", results: mainResults, totals: totals2 });
+    return mainResults;
+  }
+  options.onProgress?.({ type: "retry-start", failed });
+  const originalByKey = new Map(
+    items.map((item) => [translationItemKey(item), item])
+  );
+  const retryItems = buildRetryWorklist(failed, originalByKey);
+  const retryByKey = /* @__PURE__ */ new Map();
+  await runRetryRound(config, retryItems, {
+    model: options.model,
+    force: options.force,
+    concurrency,
+    mode,
+    onProgress: options.onProgress,
+    onResult: (result) => {
+      retryByKey.set(translationItemKey(result), result);
+      options.onProgress?.({ type: "item-done", result });
+    }
+  });
+  const results = mainResults.map((result) => {
+    if (!result.failed) return result;
+    return retryByKey.get(translationItemKey(result)) ?? result;
+  });
+  const retriedTranslated = failed.filter((original) => {
+    const retried = retryByKey.get(translationItemKey(original));
+    return retried !== void 0 && !retried.failed && !retried.skipped;
+  }).length;
   const totals = summarizeResults(results, Date.now() - startedAt);
-  options.onProgress?.({ type: "done", results, totals });
+  options.onProgress?.({ type: "done", results, totals, retriedTranslated });
   return results;
 }
 function countPendingItems(config, jobs) {