@agent-native/core 0.144.0 → 0.144.2

package/corpus/templates/slides/actions/import-file.ts

@@ -18,6 +18,12 @@ import { notifyClients } from "../server/handlers/decks.js";
 import { uploadPptxSlideImages } from "../server/handlers/import/pptx-assets.js";
 import { upsertBuilderProxyDesignSystem } from "../server/lib/builder-design-system-proxy.js";
 import { setupPdfParse } from "../server/lib/pdf-parse-setup.js";
+import {
+  buildSourceImportMetadata,
+  mergeSourceImportMetadata,
+  sourceImportForDeck,
+  type SourceImportSlideSnapshot,
+} from "../server/lib/source-import.js";
 import {
   ASPECT_RATIOS,
   DEFAULT_ASPECT_RATIO,
@@ -31,7 +37,7 @@ const DEFAULT_MAX_SOURCE_CHARS = 60_000;
 export default defineAction({
   description:
     "Import a file (PPTX, DOCX, PDF, FIG) and extract content for creating slides or slide design systems. " +
-    "For PPTX files, returns parsed slides with text and layout info ready for conversion. " +
+    "For PPTX files, returns parsed slides with text and layout info ready for conversion, or writes positioned source-preserving slides when importIntoDeck is true. " +
     "For DOCX files, returns structured sections extracted from the document. " +
     "For PDF files, returns extracted text organized by page, or source-faithful page-image slides when importIntoDeck is true. " +
     "For Figma .fig files, requires Builder.io (free tier available) and starts Builder design-system indexing; the returned Builder job/design-system ids are the source of truth. " +
@@ -153,7 +159,37 @@ export default defineAction({
           (total, r) => total + r.imageSkippedCount,
           0,
         );
-        await appendDeckSlides(deckId, title, slides, "import-file:pptx");
+        const sourceImport = buildSourceImportMetadata({
+          format: "pptx",
+          slides: pptxResults.map((result) => ({
+            id: result.slide.id,
+            text: result.sourceText,
+            notes: result.slide.notes ?? "",
+            imageUrls: result.imageUrls,
+            editableText: true,
+          })),
+          imagesSkipped,
+        });
+        if (imagesSkipped > 0) {
+          throw new Error(
+            `Source-faithful PPTX import could not preserve ${imagesSkipped} image(s). No slides were written. Retry with browser-renderable images or use a PDF export for page-faithful preservation.`,
+          );
+        }
+        const aspectRatio =
+          presentation.slides[0]?.widthEmu && presentation.slides[0]?.heightEmu
+            ? nearestAspectRatio(
+                presentation.slides[0].widthEmu,
+                presentation.slides[0].heightEmu,
+              )
+            : undefined;
+        await appendDeckSlides(
+          deckId,
+          title,
+          slides,
+          "import-file:pptx",
+          aspectRatio,
+          sourceImport,
+        );
         return {
           format: "pptx",
           title,
@@ -241,9 +277,15 @@ export default defineAction({
       // typography) bake their visuals into vector/image page content with
       // no reliable text/shape structure to reconstruct, so importing into a
       // deck rasterizes each page instead of flattening it to generic bullet
-      // text. Falls through to the text-only path below when the optional
-      // canvas renderer isn't available in this runtime.
-      if (importIntoDeck && canvasFactory) {
+      // text. Do not silently fall back to text reconstruction when the
+      // renderer is unavailable: that is how a visually complete source deck
+      // turns into a misleading, content-lossy import.
+      if (importIntoDeck) {
+        if (!canvasFactory) {
+          throw new Error(
+            "Source-faithful PDF import is unavailable in this runtime because the page renderer is not configured. Retry after connecting file storage or use a PDF export with a supported Slides deployment.",
+          );
+        }
         if (!deckId) throw new Error("deckId is required to import into deck");
         return importPdfPagesAsFullBleedSlides({
           fileBuffer,
@@ -254,8 +296,6 @@ export default defineAction({
         });
       }
 
-      const { convertSectionsToSlides } =
-        await import("../server/handlers/import/html-converter.js");
       const pdf = new PDFParse({
         data: new Uint8Array(fileBuffer),
         CanvasFactory: canvasFactory,
@@ -270,29 +310,6 @@ export default defineAction({
         );
       }
 
-      if (importIntoDeck) {
-        if (!deckId) throw new Error("deckId is required to import into deck");
-        const sections = textPages.map((p) => ({
-          heading: `Page ${p.num}`,
-          content: p.text,
-        }));
-        const slideHtmlArray = convertSectionsToSlides(sections);
-        const slides = slideHtmlArray.map((content) => ({
-          id: newSlideId(),
-          content,
-          layout: "content",
-          notes: "",
-        }));
-        await appendDeckSlides(deckId, title, slides, "import-file:pdf");
-        return {
-          format: "pdf",
-          title,
-          pageCount: pages.length,
-          slideCount: slides.length,
-          deckId,
-          imported: true,
-        };
-      }
       const totalTextLength = textPages.reduce(
         (sum, p) => sum + p.text.length,
         0,
@@ -342,7 +359,7 @@ async function importPdfPagesAsFullBleedSlides(args: {
   canvasFactory: object;
 }) {
   const { fileBuffer, title, deckId, PDFParse, canvasFactory } = args;
-  const { buildFullPageImageSlideHtml, convertSectionsToSlides } =
+  const { buildFullPageImageSlideHtml } =
     await import("../server/handlers/import/html-converter.js");
 
   const pdf = new PDFParse({
@@ -355,7 +372,15 @@ async function importPdfPagesAsFullBleedSlides(args: {
     { data: Uint8Array; width: number; height: number }
   >;
   try {
-    pages = normalizePdfPages(await pdf.getText());
+    let textPages: { num: number; text: string }[] = [];
+    try {
+      textPages = normalizePdfPages(await pdf.getText());
+    } catch (error) {
+      console.warn(
+        "[import-file] PDF text extraction failed; preserving rendered pages and leaving notes empty:",
+        error,
+      );
+    }
     // Rasterize the complete page so positioned text, vector shapes, logos,
     // photos, and the source page proportions survive the import together.
     const screenshotResult = await pdf.getScreenshot({
@@ -371,10 +396,23 @@ async function importPdfPagesAsFullBleedSlides(args: {
         height: page.height,
       });
     }
+    if (screenshotsByPage.size === 0) {
+      throw new Error("The PDF renderer returned no pages.");
+    }
+    pages = screenshotResult.pages.map((page) => ({
+      num: page.pageNumber,
+      text:
+        textPages.find((textPage) => textPage.num === page.pageNumber)?.text ??
+        "",
+    }));
   } finally {
     await pdf.destroy();
   }
 
+  if (pages.length === 0) {
+    throw new Error("The PDF renderer returned no importable pages.");
+  }
+
   // Source decks (e.g. Instagram carousel exports) are commonly portrait or
   // square, not the deck editor's 16:9 default — match the canvas to the
   // first rendered page's own proportions instead of stretching/cropping it.
@@ -386,24 +424,14 @@ async function importPdfPagesAsFullBleedSlides(args: {
     : undefined;
 
   const ownerEmail = getRequestUserEmail();
-  const slides = await Promise.all(
+  const imported = await Promise.all(
     pages.map(async (page) => {
-      const lines = page.text
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
       const screenshot = screenshotsByPage.get(page.num);
 
       if (!screenshot) {
-        const [content] = convertSectionsToSlides([
-          { heading: lines[0] ?? `Page ${page.num}`, content: page.text },
-        ]);
-        return {
-          id: newSlideId(),
-          content: content ?? '<div class="fmd-slide"></div>',
-          layout: "content",
-          notes: "",
-        };
+        throw new Error(
+          `The PDF renderer did not return page ${page.num}; refusing a partial source import.`,
+        );
       }
 
       const uploadResult = await uploadFile({
@@ -418,16 +446,42 @@ async function importPdfPagesAsFullBleedSlides(args: {
           "File storage is not configured. Connect Builder.io (free tier available) or another upload provider before importing PDF slides.",
         );
       }
+      const id = newSlideId();
       return {
-        id: newSlideId(),
-        content: buildFullPageImageSlideHtml(uploadResult.url),
-        layout: "full-image",
-        notes: page.text,
+        slide: {
+          id,
+          content: buildFullPageImageSlideHtml(
+            uploadResult.url,
+            screenshot.width,
+            screenshot.height,
+          ),
+          layout: "full-image",
+          notes: page.text,
+        },
+        snapshot: {
+          id,
+          text: page.text,
+          notes: page.text,
+          imageUrls: [uploadResult.url],
+          editableText: false,
+        } satisfies SourceImportSlideSnapshot,
       };
     }),
   );
+  const slides = imported.map((entry) => entry.slide);
+  const sourceImport = buildSourceImportMetadata({
+    format: "pdf",
+    slides: imported.map((entry) => entry.snapshot),
+  });
 
-  await appendDeckSlides(deckId, title, slides, "import-file:pdf", aspectRatio);
+  await appendDeckSlides(
+    deckId,
+    title,
+    slides,
+    "import-file:pdf",
+    aspectRatio,
+    sourceImport,
+  );
 
   return {
     format: "pdf",
@@ -459,6 +513,8 @@ async function buildPptxSlide(
     splitByParagraph?: boolean;
   };
   imageSkippedCount: number;
+  sourceText: string;
+  imageUrls: string[];
 }> {
   const { convertToSlideHtml } =
     await import("../server/handlers/import/html-converter.js");
@@ -467,9 +523,10 @@ async function buildPptxSlide(
     slideIndex,
     ownerEmail,
   });
+  const id = newSlideId();
   return {
     slide: {
-      id: newSlideId(),
+      id,
       content: convertToSlideHtml(slide, uploadedImages.urls, themeFont),
       layout: slide.layoutHint ?? "content",
       notes: slide.notes,
@@ -477,6 +534,8 @@ async function buildPptxSlide(
       ...(slide.splitByParagraph ? { splitByParagraph: true } : {}),
     },
     imageSkippedCount: uploadedImages.imageSkippedCount,
+    sourceText: slide.texts.map((text) => text.content).join("\n"),
+    imageUrls: Object.values(uploadedImages.urls),
   };
 }
 
@@ -568,6 +627,7 @@ async function appendDeckSlides(
   }>,
   source: string,
   aspectRatio?: AspectRatio,
+  sourceImport?: ReturnType<typeof buildSourceImportMetadata>,
 ) {
   await assertAccess("deck", deckId, "editor");
 
@@ -601,11 +661,18 @@ async function appendDeckSlides(
     // every slide already on it.
     const hadExistingSlides = previousSlides.length > 0;
     const nextTitle = hadExistingSlides ? (existing[0].title ?? title) : title;
+    const nextSourceImport = sourceImport
+      ? mergeSourceImportMetadata(
+          sourceImportForDeck(previousData.sourceImport),
+          sourceImport,
+        )
+      : sourceImportForDeck(previousData.sourceImport);
     const data = {
       ...previousData,
       title: nextTitle,
       slides: [...previousSlides, ...slides],
       ...(!hadExistingSlides && aspectRatio ? { aspectRatio } : {}),
+      ...(nextSourceImport ? { sourceImport: nextSourceImport } : {}),
       updatedAt: writeNow,
     };
 
@@ -626,12 +693,20 @@ async function appendDeckSlides(
 }
 
 function safeParseDeckData(raw: string): Record<string, unknown> {
+  let parsed: unknown;
   try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" ? parsed : {};
+    parsed = JSON.parse(raw);
   } catch {
-    return {};
+    throw new Error(
+      "The target deck contains invalid JSON; refusing to overwrite it.",
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      "The target deck data is invalid; refusing to overwrite it.",
+    );
   }
+  return parsed as Record<string, unknown>;
 }
 
 function stripTags(html: string): string {

package/corpus/templates/slides/actions/import-pptx.ts

@@ -19,6 +19,12 @@ import {
   type ParsedImage,
   type ParsedPresentation,
 } from "../server/handlers/import/pptx-parser.js";
+import { buildSourceImportMetadata } from "../server/lib/source-import.js";
+import {
+  ASPECT_RATIOS,
+  DEFAULT_ASPECT_RATIO,
+  type AspectRatio,
+} from "../shared/aspect-ratios.js";
 import { getDeckUrl } from "./_app-url.js";
 import { readUserUploadedFile } from "./_uploaded-files.js";
 
@@ -82,6 +88,7 @@ export async function importPptxBufferToDeck(args: {
   fileBuffer: Buffer;
   title?: string;
   deckId?: string;
+  designSystemId?: string | null;
   source?: string;
   imageFallbacks?: ImportedImageFallback[];
   parsedPresentation?: ParsedPresentation;
@@ -98,6 +105,7 @@ export async function importPptxBufferToDeck(args: {
     fileBuffer,
     title,
     deckId,
+    designSystemId,
     source = "import-pptx",
     imageFallbacks,
     parsedPresentation,
@@ -133,9 +141,10 @@ export async function importPptxBufferToDeck(args: {
           uploadedImages.urls,
           themeFont,
         );
+        const id = `slide-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
         return {
           slide: {
-            id: `slide-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+            id,
             content: html,
             layout: parsedSlide.layoutHint ?? "content",
             notes: parsedSlide.notes,
@@ -144,6 +153,8 @@ export async function importPptxBufferToDeck(args: {
               : {}),
             ...(parsedSlide.splitByParagraph ? { splitByParagraph: true } : {}),
           },
+          sourceText: parsedSlide.texts.map((text) => text.content).join("\n"),
+          imageUrls: Object.values(uploadedImages.urls),
           imageSkippedCount: uploadedImages.imageSkippedCount,
         };
       }),
@@ -154,6 +165,26 @@ export async function importPptxBufferToDeck(args: {
     (total, r) => total + r.imageSkippedCount,
     0,
   );
+  if (imagesSkipped > 0) {
+    throw new Error(
+      `Source-faithful PPTX import could not preserve ${imagesSkipped} image(s). No deck was written. Retry with browser-renderable images or use a PDF export for page-faithful preservation.`,
+    );
+  }
+  const sourceImport = buildSourceImportMetadata({
+    format: "pptx",
+    slides: results.map((result) => ({
+      id: result.slide.id,
+      text: result.sourceText,
+      notes: result.slide.notes ?? "",
+      imageUrls: result.imageUrls,
+      editableText: true,
+    })),
+    imagesSkipped,
+  });
+  const aspectRatio = nearestAspectRatio(
+    presentation.slides[0]?.widthEmu,
+    presentation.slides[0]?.heightEmu,
+  );
 
   const db = getDb();
   const now = new Date().toISOString();
@@ -168,10 +199,25 @@ export async function importPptxBufferToDeck(args: {
       throw new Error(`Deck ${deckId} not found`);
     }
 
-    const data = { title: deckTitle, slides, updatedAt: now };
+    const previousData = safeParseDeckData(existing[0].data);
+    const data = {
+      ...previousData,
+      title: deckTitle,
+      slides,
+      ...(aspectRatio ? { aspectRatio } : {}),
+      sourceImport,
+      updatedAt: now,
+    };
     await db
       .update(schema.decks)
-      .set({ title: deckTitle, data: JSON.stringify(data), updatedAt: now })
+      .set({
+        title: deckTitle,
+        data: JSON.stringify(data),
+        ...(designSystemId !== undefined
+          ? { designSystemId }
+          : { designSystemId: existing[0].designSystemId }),
+        updatedAt: now,
+      })
       .where(eq(schema.decks.id, deckId));
 
     notifyClients(deckId);
@@ -193,13 +239,21 @@ export async function importPptxBufferToDeck(args: {
 
   // Create new deck
   const id = `deck-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-  const data = { title: deckTitle, slides, createdAt: now, updatedAt: now };
+  const data = {
+    title: deckTitle,
+    slides,
+    ...(aspectRatio ? { aspectRatio } : {}),
+    sourceImport,
+    createdAt: now,
+    updatedAt: now,
+  };
   await db.insert(schema.decks).values({
     id,
     title: deckTitle,
     data: JSON.stringify(data),
     ownerEmail,
     orgId: getRequestOrgId(),
+    designSystemId: designSystemId ?? undefined,
     createdAt: now,
     updatedAt: now,
   });
@@ -222,8 +276,8 @@ export default defineAction({
   description:
     "Import a PPTX file and create a slide deck from it. " +
     "Parses the PowerPoint file, extracts text and layout information, " +
-    "converts each slide to the app's HTML format, and creates or updates a deck. " +
-    "Returns the deck ID and slide count.",
+    "converts each slide to the app's positioned HTML format, records source-preservation metadata, and creates or updates a deck. " +
+    "If an embedded image cannot be preserved, the action fails before writing a partial deck. Returns the deck ID and slide count.",
   schema: z.object({
     filePath: z
       .string()
@@ -234,6 +288,11 @@ export default defineAction({
       .describe(
         "If provided, import slides into this existing deck (replaces all slides)",
       ),
+    designSystemId: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("Optional design system to link when creating a new deck"),
     title: z
       .string()
       .optional()
@@ -241,8 +300,49 @@ export default defineAction({
         "Deck title — defaults to the title extracted from the presentation",
       ),
   }),
-  run: async ({ filePath, deckId, title }) => {
+  run: async ({ filePath, deckId, title, designSystemId }) => {
     const { data: fileBuffer } = await readUserUploadedFile(filePath);
-    return importPptxBufferToDeck({ fileBuffer, deckId, title });
+    return importPptxBufferToDeck({
+      fileBuffer,
+      deckId,
+      title,
+      designSystemId,
+    });
   },
 });
+
+function nearestAspectRatio(
+  width: number | undefined,
+  height: number | undefined,
+): AspectRatio | undefined {
+  if (!width || !height || width <= 0 || height <= 0) return undefined;
+  const target = width / height;
+  let best: AspectRatio = DEFAULT_ASPECT_RATIO;
+  let bestDiff = Infinity;
+  for (const key of Object.keys(ASPECT_RATIOS) as AspectRatio[]) {
+    const preset = ASPECT_RATIOS[key];
+    const diff = Math.abs(preset.width / preset.height - target);
+    if (diff < bestDiff) {
+      best = key;
+      bestDiff = diff;
+    }
+  }
+  return best;
+}
+
+function safeParseDeckData(raw: string): Record<string, unknown> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(
+      "The target deck contains invalid JSON; refusing to overwrite it.",
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      "The target deck data is invalid; refusing to overwrite it.",
+    );
+  }
+  return parsed as Record<string, unknown>;
+}

package/corpus/templates/slides/actions/patch-deck.ts

@@ -26,6 +26,11 @@ import { z } from "zod";
 import { normalizeSlidePadding } from "../app/lib/normalize-slide-padding.js";
 import { getDb, schema } from "../server/db/index.js";
 import { notifyClients } from "../server/handlers/decks.js";
+import {
+  assertSourceSlidePreserved,
+  sourceImportForDeck,
+  type SourceImportMetadata,
+} from "../server/lib/source-import.js";
 import { ASPECT_RATIO_VALUES } from "../shared/aspect-ratios.js";
 
 // ---------------------------------------------------------------------------
@@ -79,6 +84,13 @@ const PatchSlideOp = z.object({
   op: z.literal("patch-slide"),
   slideId: z.string(),
   fields: SlideFieldsSchema,
+  preserveSource: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe(
+      "Keep source-imported images and factual copy (default true). Set false only for an explicit rewrite.",
+    ),
 });
 
 /** Delete a single slide by ID */
@@ -141,6 +153,24 @@ export const OperationSchema = z.discriminatedUnion("op", [
 
 export type Operation = z.infer<typeof OperationSchema>;
 
+export function assertSourceImportOperationsPreserved(
+  metadata: SourceImportMetadata | null,
+  operations: Operation[],
+): void {
+  if (!metadata) return;
+  const structuralOperation = operations.find(
+    (operation) =>
+      operation.op === "delete-slide" ||
+      operation.op === "reorder-slides" ||
+      operation.op === "add-slide",
+  );
+  if (!structuralOperation) return;
+
+  throw new Error(
+    `Cannot ${structuralOperation.op} on a source-imported deck while source preservation is enabled. Preserve the imported slide structure, or use an explicit source rewrite workflow.`,
+  );
+}
+
 // The browser uses the full operation union above. Agents additionally use
 // this action for one bounded, deck-wide layout repair: one patch-slide per
 // slide in a single SQL transaction, followed by a fresh read for verification.
@@ -404,6 +434,27 @@ export default defineAction({
         );
       }
 
+      const sourceImport = sourceImportForDeck(deck.sourceImport);
+      assertSourceImportOperationsPreserved(sourceImport, operations);
+      for (const op of operations) {
+        if (
+          op.op !== "patch-slide" ||
+          (op.fields.content === undefined && op.fields.notes === undefined)
+        ) {
+          continue;
+        }
+        assertSourceSlidePreserved({
+          metadata: sourceImport,
+          slideId: op.slideId,
+          nextContent:
+            op.fields.content === undefined
+              ? undefined
+              : normalizeSlidePadding(op.fields.content),
+          nextNotes: op.fields.notes,
+          preserveSource: op.preserveSource,
+        });
+      }
+
       for (const op of operations) {
         applyOperation(deck, op);
       }

package/corpus/templates/slides/actions/update-slide.ts

@@ -16,6 +16,10 @@ import { normalizeSlidePadding } from "../app/lib/normalize-slide-padding.js";
 import { getDb, schema } from "../server/db/index.js"; // ensure registerShareableResource runs
 import { notifyClients } from "../server/handlers/decks.js";
 import { createDeckVersionSnapshot } from "../server/lib/deck-versions.js";
+import {
+  assertSourceSlidePreserved,
+  sourceImportForDeck,
+} from "../server/lib/source-import.js";
 import { hashSlideContent } from "../shared/slide-fit.js";
 import { slideLabelFor, touchAgentSlidePresence } from "./_agent-presence.js";
 import {
@@ -89,7 +93,7 @@ function storedCreativeContext(value: unknown): {
 export default defineAction({
   description:
     "Surgically edit a slide's content using search-replace or full replacement. " +
-    "Syncs live to open editors. Prefer this over full deck rewrites.",
+    "Syncs live to open editors. Prefer this over full deck rewrites. Source-imported slides preserve their original images and factual copy by default.",
   schema: z.object({
     deckId: z.string().describe("Deck ID"),
     slideId: z.string().describe("Slide ID"),
@@ -105,6 +109,13 @@ export default defineAction({
       .string()
       .optional()
       .describe("Full HTML to replace entire slide content"),
+    preserveSource: z
+      .boolean()
+      .optional()
+      .default(true)
+      .describe(
+        "Keep source-imported images and factual copy (default true). Set false only when the user explicitly asks to rewrite the source slide.",
+      ),
     contextPackId: z
       .string()
       .optional()
@@ -131,6 +142,7 @@ export default defineAction({
       find,
       replace,
       fullContent,
+      preserveSource,
       contextPackId,
       contextModeOverride,
       reuseLabels,
@@ -205,17 +217,31 @@ export default defineAction({
       let notFound = false;
 
       if (fullContent) {
-        slide.content = normalizeSlidePadding(fullContent);
+        const nextContent = normalizeSlidePadding(fullContent);
+        assertSourceSlidePreserved({
+          metadata: sourceImportForDeck(deck.sourceImport),
+          slideId,
+          nextContent,
+          preserveSource,
+        });
+        slide.content = nextContent;
         applied = true;
       } else if (find) {
         const idx = (slide.content as string).indexOf(find);
         if (idx === -1) {
           notFound = true;
         } else {
-          slide.content =
+          const nextContent =
             slide.content.slice(0, idx) +
             (replace ?? "") +
             slide.content.slice(idx + find.length);
+          assertSourceSlidePreserved({
+            metadata: sourceImportForDeck(deck.sourceImport),
+            slideId,
+            nextContent,
+            preserveSource,
+          });
+          slide.content = nextContent;
           applied = true;
         }
       }

package/corpus/templates/slides/app/components/onboarding/FirstDeckOnboardingFlow.tsx

@@ -157,6 +157,17 @@ export function FirstDeckOnboardingFlow({
             ),
           });
         },
+        onSetupFailure: (failedPrompt, _failedFiles, failure) => {
+          setPromptInitialText(failedPrompt);
+          setPromptInitialTextKey(Date.now());
+          setStep("prompt");
+          toast.error(t("home.generationStartFailed"), {
+            description:
+              failure instanceof Error
+                ? failure.message
+                : t("home.generationStartFailedDescription"),
+          });
+        },
       });
       if (result === "started") onComplete();
     },