@agent-native/core 0.141.7 → 0.144.1

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

@@ -29,6 +29,8 @@ import {
   type RecentReference,
 } from "@/lib/recent-references";
 
+import { MAX_REFERENCE_FILE_BYTES } from "../../../shared/upload-types";
+
 type FirstDeckStep = "prompt" | "references";
 
 export function FirstDeckOnboardingFlow({
@@ -155,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();
     },
@@ -303,6 +316,8 @@ export function FirstDeckOnboardingFlow({
             className="mt-8"
             autoFocus
             attachmentsEnabled
+            maxDocumentAttachmentBytes={MAX_REFERENCE_FILE_BYTES}
+            documentAttachmentLimitLabel="Slides reference files"
             disabled={uploading}
             placeholder={t("home.newDeckPlaceholder")}
             onSubmit={handlePromptSubmit}

package/corpus/templates/slides/app/components/presentation/PresentationView.tsx

@@ -18,6 +18,7 @@ import type {
 import type { AspectRatio } from "@/lib/aspect-ratios";
 import {
   findLegacyAnimationContainer,
+  getElementPath,
   resolveSlideAnimationElement,
 } from "@/lib/slide-animation-elements";
 
@@ -43,6 +44,31 @@ function getAnimationSteps(slide: Slide): SlideAnimation[] | null {
     const doc = new DOMParser().parseFromString(slide.content, "text/html");
     const root = doc.querySelector(".fmd-slide");
     if (!root) return null;
+
+    const paragraphs = Array.from(
+      root.querySelectorAll(".fmd-pptx-text p[data-pptx-paragraph]"),
+    ).filter((paragraph) => {
+      const textBox = paragraph.closest(".fmd-pptx-text");
+      return (
+        (textBox?.querySelectorAll("p[data-pptx-paragraph]").length ?? 0) > 1
+      );
+    });
+    if (paragraphs.length > 1) {
+      return paragraphs.flatMap((paragraph, index) => {
+        const elementPath = getElementPath(root, paragraph);
+        return elementPath
+          ? [
+              {
+                id: `auto-paragraph-${index}`,
+                elementIndex: index,
+                elementPath,
+                type: "slide-up" as AnimationType,
+              },
+            ]
+          : [];
+      });
+    }
+
     const container = findLegacyAnimationContainer(root);
     if (!container) return null;
     return Array.from(container.children).map((_, i) => ({
@@ -103,7 +129,7 @@ function annotateStepsForPresentation(
     })
     .join("\n");
 
-  const styleTag = `<style>[data-pstep] { opacity: 0; pointer-events: none; }\n${styleLines}</style>`;
+  const styleTag = `<style>[data-pstep] { opacity: 0; pointer-events: none; visibility: visible !important; }\n${styleLines}</style>`;
   return styleTag + doc.body.innerHTML;
 }
 

package/corpus/templates/slides/app/i18n/en-US.ts

@@ -684,6 +684,7 @@ const messages = {
     googleSlidesReferenceConnect:
       "Connect Google Drive to import a Slides deck.",
     googleSlidesReferenceChoose: "Choose Google Slides deck",
+    googleSlidesReferenceUrl: "Paste a Google Slides link",
     googleSlidesReferencePicking: "Working...",
     googleSlidesReferenceConnected:
       "Connected. Choose a Google Slides deck to import as a reusable reference.",

package/corpus/templates/slides/app/lib/create-deck-generation.ts

@@ -6,6 +6,10 @@ import type { NewDeckReferenceSelection } from "@/components/editor/NewDeckRefer
 import type { UploadedFile } from "@/components/editor/PromptDialog";
 import type { Deck, DeckPersistenceResult } from "@/context/DeckContext";
 import { createDeckAgentMessage } from "@/lib/agent-visible-message";
+import {
+  importUploadedDeckIntoDeck,
+  type ImportedSourceDeck,
+} from "@/lib/import-uploaded-deck";
 
 interface DesignSystemGenerationContextResult {
   agentContext?: string;
@@ -85,6 +89,7 @@ async function loadReferenceDeckGenerationContext(
 function describeUploadedFilesForAgent(
   files: UploadedFile[],
   deckId: string,
+  importedSourceDeck?: ImportedSourceDeck | null,
 ): string {
   if (files.length === 0) return "";
   const fileList = files
@@ -93,14 +98,21 @@ function describeUploadedFilesForAgent(
         `- ${file.originalName} (${file.type}, ${(file.size / 1024).toFixed(1)}KB) at path: ${file.path}${file.url ? `; embeddable URL: ${file.url}` : ""}`,
     )
     .join("\n");
+  const sourceFile = importedSourceDeck?.file;
   return [
     "",
-    `The user uploaded ${files.length} file(s). These paths are real uploaded files; process them with import actions before using their contents:`,
+    importedSourceDeck
+      ? `The user uploaded ${files.length} file(s). The ${sourceFile?.originalName ?? importedSourceDeck.format.toUpperCase()} source deck has already been imported into target deck ${deckId} with ${importedSourceDeck.slideCount} source slide(s); do not import it again.`
+      : `The user uploaded ${files.length} file(s). These paths are real uploaded files; process them with import actions before using their contents:`,
     fileList,
     "",
     "File handling rules:",
-    `- PPTX files: call \`import-pptx --filePath \"<path>\" --deckId ${deckId}\` before adding or editing slides.`,
-    `- PDF and DOCX files: call \`import-file --filePath \"<path>\" --format auto --deckId ${deckId}\` and use the returned extracted text as source material. The returned text is capped for reliability; re-run with maxChars only if more context is needed.`,
+    importedSourceDeck
+      ? "- The imported source deck is the canonical source. Preserve its slide count, order, IDs, factual copy, notes, imagery, charts, tables, diagrams, and freeform objects while improving styling. Use update-slide on existing slide IDs; do not rebuild it with add-slide."
+      : `- PPTX files: call \`import-pptx --filePath \"<path>\" --deckId ${deckId}\` before adding or editing slides.`,
+    importedSourceDeck
+      ? "- For a PDF source, keep the original full-page image in every slide and add restrained design-system chrome around it without obscuring source content. Never OCR-reconstruct a source-faithful page from extracted text."
+      : `- PDF and DOCX files: call \`import-file --filePath \"<path>\" --format auto --deckId ${deckId}\` and use the returned extracted text as source material. For a visual PDF whose original layout should be preserved, pass \`--importIntoDeck true\` instead of rebuilding the pages from extracted text.`,
     "- Text-like files: use the uploaded-text-file blocks already included in the prompt; do not call import-file for them.",
     '- Image files with an embeddable URL can be inserted directly into slide HTML as `<img src="...">` or used as visual references.',
     "- Image files without a URL are visual/reference assets only; do not claim to have processed a PPTX/PDF/DOCX unless the relevant import action succeeds.",
@@ -161,6 +173,11 @@ export interface StartDeckGenerationOptions {
     files: UploadedFile[],
     failure: DeckPersistenceResult,
   ) => void;
+  onSetupFailure: (
+    prompt: string,
+    files: UploadedFile[],
+    failure: unknown,
+  ) => void;
 }
 
 /** Create the optimistic deck, hydrate references, and start the agent run. */
@@ -181,6 +198,7 @@ export async function startDeckGeneration({
   onPromptClosed,
   onUnauthenticated,
   onPersistenceFailure,
+  onSetupFailure,
 }: StartDeckGenerationOptions): Promise<
   "started" | "failed" | "unauthenticated"
 > {
@@ -215,7 +233,6 @@ export async function startDeckGeneration({
   });
   if (!deck) return "failed";
   const deckId = deck.id;
-  onPromptClosed();
 
   const persisted = await ensureDeckPersisted(deck.id);
   if (!persisted.persisted) {
@@ -224,6 +241,20 @@ export async function startDeckGeneration({
     return "failed";
   }
 
+  let importedSourceDeck: ImportedSourceDeck | null = null;
+  try {
+    importedSourceDeck = await importUploadedDeckIntoDeck(
+      filesForGeneration,
+      deckId,
+    );
+  } catch (error) {
+    deleteDeck(deckId);
+    onSetupFailure(prompt, filesForGeneration, error);
+    return "failed";
+  }
+
+  onPromptClosed();
+
   navigate(`/deck/${deck.id}`, { flushSync: true });
 
   const trimmedPrompt = prompt.trim();
@@ -231,7 +262,11 @@ export async function startDeckGeneration({
   const googleDocUrls = hasImportedGoogleDocContext
     ? []
     : extractGoogleDocUrls(trimmedPrompt);
-  const fileContext = describeUploadedFilesForAgent(filesForGeneration, deckId);
+  const fileContext = describeUploadedFilesForAgent(
+    filesForGeneration,
+    deckId,
+    importedSourceDeck,
+  );
   const googleDocContext =
     googleDocUrls.length > 0
       ? [
@@ -260,7 +295,9 @@ export async function startDeckGeneration({
     : [
         "",
         "Design system selection:",
-        "- None selected. Do not apply a design system unless the user asks for one.",
+        "- No design system was selected in the picker.",
+        "- Before generating a bare or on-brand deck, call `get-workspace-defaults`. If it returns a usable design system, patch this deck with that designSystemId, call `get-design-system`, and follow its exact tokens, assets, and custom instructions.",
+        "- If no workspace default exists, use the product's configured design-system action and report the missing configuration instead of inventing a generic Builder-like palette.",
       ].join("\n");
   const referenceSource = referenceSelection.referenceSource;
   const referenceSourceContext = referenceSource
@@ -275,21 +312,45 @@ export async function startDeckGeneration({
             : "Use the Figma source as the design reference. If Builder or Figma access is required, report the exact connection step instead of guessing.",
       ].join("\n")
     : "";
+  const sourceDeckContext = importedSourceDeck
+    ? [
+        "",
+        "Source-preserving improvement mode:",
+        `- The target deck already contains ${importedSourceDeck.slideCount} imported source slides. Treat those slides as the user's complete source, not as inspiration for a new deck.`,
+        "- Keep the exact source slide count, order, IDs, factual meaning, notes, images, charts, tables, diagrams, and freeform objects unless the user explicitly asks to change one of them.",
+        "- Read `get-deck` before editing, load the linked design system with `get-design-system`, then use one `update-slide` call per existing slide ID for bounded visual improvements. Keep every original `<img>` source and enough original factual copy for each slide; for PDF slides, use restrained design-system chrome around the page without obscuring it.",
+        "- Do not call `add-slide`, delete slides, reorder slides, or replace source images with generic cards. Do not claim success until `get-deck` verifies the same slide IDs and count after the edits.",
+        "- If `get-deck` reports partial source fidelity or skipped images, stop and report the exact warning instead of claiming a reliable restyle.",
+      ].join("\n")
+    : "";
+  const sourceModeInstructions = importedSourceDeck
+    ? [
+        "The request is an in-place visual improvement of an imported source deck. Make a coherent style pass across every existing slide while preserving all source content and media.",
+        "Do not use the new-deck add-slide workflow for this source-preserving request.",
+      ]
+    : [
+        "Start a `manage-progress` run so progress appears in the app header. Add the first slide as soon as it is ready, then continue one slide at a time so the editor visibly fills in.",
+        `After reading any requested or imported source material, but before adding the first slide, choose a concise, specific deck title from the user's request and source material. Call \`patch-deck\` with \`deckId: \"${deckId}\"\` and \`operations: [{ \"op\": \"patch-deck-fields\", \"fields\": { \"title\": \"<generated title>\" } }]\`. Include only \`title\` in \`fields\`; omit all other optional fields. Never leave a generated deck named \"Untitled Deck\" or another placeholder.`,
+        "If the user asks for a standalone visual, diagram, hero, one-pager, poster, or a couple of visuals, create only the requested one/few polished visual slides. Do not pad the result into a full presentation.",
+        "If the request is for a presentation or deck and does not explicitly ask for one slide, infer a coherent multi-slide outline from the scope and keep adding slides until that outline is complete. Do not stop after the first slide just because the prompt has few explicit instructions.",
+        `Add slides ONE AT A TIME using the \`add-slide\` action with --deckId=${deckId}. Wait for each \`add-slide\` result before calling it again; do not batch or parallelize slide writes.`,
+        "Use create-deck and add-slide for this already-created deck. Do not call the legacy generate-slides-ai action: it returns Markdown drafts rather than persisted rendered slide HTML. Treat each successful add-slide result as confirmation to continue with the next planned slide.",
+      ].join("\n");
 
   const context = [
-    `The user just created a new empty deck (id: "${deckId}") and wants to create a presentation or standalone visual.`,
+    importedSourceDeck
+      ? `The user uploaded a source presentation into target deck (id: "${deckId}") and wants a reliable visual improvement.`
+      : `The user just created a new empty deck (id: "${deckId}") and wants to create a presentation or standalone visual.`,
     "The visible user message above contains the user's request and/or pasted source material for the deck. Treat pasted memo content as source material even if the user did not explicitly say they are pasting it.",
     googleDocContext,
     fileContext,
     referenceDeckContext,
     designSystemContext,
     referenceSourceContext,
+    sourceDeckContext,
     "",
     "Before generating, if the request or selected references leave a meaningful choice unresolved, use the `ask-question` tool to ask one concise, prompt-specific question in the inline guided-question flow. Generate the question wording and 2 to 4 options from the user's request and selected references, like Claude's design-question flow; do not use a fixed generic questionnaire. Ask only a choice that materially affects the deck, such as audience, tone, structure, or length. If the prompt already makes the choice clear, do not ask it again. Wait for the user's answer or skip before adding slides.",
-    "Start a `manage-progress` run so progress appears in the app header. Add the first slide as soon as it is ready, then continue one slide at a time so the editor visibly fills in.",
-    `After reading any requested or imported source material, but before adding the first slide, choose a concise, specific deck title from the user's request and source material. Call \`patch-deck\` with \`deckId: \"${deckId}\"\` and \`operations: [{ \"op\": \"patch-deck-fields\", \"fields\": { \"title\": \"<generated title>\" } }]\`. Include only \`title\` in \`fields\`; omit all other optional fields. Never leave a generated deck named \"Untitled Deck\" or another placeholder.`,
-    "If the user asks for a standalone visual, diagram, hero, one-pager, poster, or a couple of visuals, create only the requested one/few polished visual slides. Do not pad the result into a full presentation.",
-    `Add slides ONE AT A TIME using the \`add-slide\` action with --deckId=${deckId}. Wait for each \`add-slide\` result before calling it again; do not batch or parallelize slide writes.`,
+    sourceModeInstructions,
     "If the user asked for a specific slide count, keep going sequentially until that count is reached unless a tool error blocks you.",
     "Every slide is rendered into a fixed native canvas (default 16:9 is 960x540 CSS pixels, with 740x380px available inside standard 80px 110px padding). Keep the main content within that fit budget; split dense source material across more slides instead of packing it tightly. Never use zoom, transform: scale(), clipping, or scroll overflow to hide content overflow, and keep body text at least 16px.",
     "Each slide's --content must be full HTML. Slide HTML templates are in your AGENTS.md.",

package/corpus/templates/slides/app/lib/deck-preview-frame.ts

@@ -0,0 +1,15 @@
+import { getAspectRatioDims, type AspectRatio } from "./aspect-ratios";
+
+const LISTING_FRAME_RATIO = 16 / 9;
+
+export function getDeckListingPreviewFrameStyle(aspectRatio?: AspectRatio) {
+  const dimensions = getAspectRatioDims(aspectRatio);
+  const isListingRatio =
+    dimensions.width / dimensions.height >= LISTING_FRAME_RATIO;
+
+  return {
+    aspectRatio: `${dimensions.width} / ${dimensions.height}`,
+    height: "100%",
+    width: isListingRatio ? "100%" : "auto",
+  };
+}

package/corpus/templates/slides/app/lib/deck-share-links.ts

@@ -0,0 +1,9 @@
+export type DeckShareLinkKind = "editor" | "presentation";
+
+export function getDeckShareLinkOrder(
+  visibility?: "private" | "org" | "public",
+): { primary: DeckShareLinkKind; secondary: DeckShareLinkKind } {
+  return visibility === "public"
+    ? { primary: "presentation", secondary: "editor" }
+    : { primary: "editor", secondary: "presentation" };
+}

package/corpus/templates/slides/app/lib/export-pptx-client.ts

@@ -313,6 +313,94 @@ function widenNoWrapTextElements(root: HTMLElement) {
   }
 }
 
+/**
+ * dom-to-pptx serializes CSS gradients as one malformed diagonal SVG. Imported
+ * slides use a repeated master grid, so materialize that grid as a transparent
+ * image before handing the clone to the exporter and leave the real text and
+ * image objects editable.
+ */
+function materializeImportedBackgroundGrid(root: HTMLElement) {
+  const slideRoot = root.matches(".fmd-imported-pptx")
+    ? root
+    : root.querySelector<HTMLElement>(".fmd-imported-pptx");
+  if (!slideRoot) return;
+  const computed = window.getComputedStyle(slideRoot);
+  if (!computed.backgroundImage.includes("linear-gradient")) return;
+
+  const color = computed.backgroundImage.match(/rgb\([^)]*\)/)?.[0];
+  const size = computed.backgroundSize
+    .split(",")[0]
+    ?.trim()
+    .split(/\s+/)
+    .map((value) => Number.parseFloat(value));
+  const position = computed.backgroundPosition
+    .split(",")[0]
+    ?.trim()
+    .split(/\s+/)
+    .map((value) => Number.parseFloat(value));
+  const declaredLineWidth = computed.backgroundImage.match(
+    /\b0(?:px)?\s+([\d.]+)px\b/i,
+  )?.[1];
+  const lineWidth = declaredLineWidth
+    ? Number.parseFloat(declaredLineWidth)
+    : Number.NaN;
+  if (
+    !color ||
+    !size ||
+    size.length < 2 ||
+    !Number.isFinite(size[0]) ||
+    !Number.isFinite(size[1]) ||
+    size[0] <= 0 ||
+    size[1] <= 0 ||
+    !position ||
+    position.length < 2 ||
+    !Number.isFinite(position[0]) ||
+    !Number.isFinite(position[1]) ||
+    !Number.isFinite(lineWidth)
+  ) {
+    return;
+  }
+
+  const canvas = document.createElement("canvas");
+  canvas.width = Math.max(1, Math.round(slideRoot.clientWidth));
+  canvas.height = Math.max(1, Math.round(slideRoot.clientHeight));
+  const context = canvas.getContext("2d");
+  if (!context) return;
+  context.strokeStyle = color;
+  context.lineWidth = Math.max(0.5, lineWidth);
+
+  for (let x = position[0]; x < canvas.width; x += size[0]) {
+    context.beginPath();
+    context.moveTo(x + context.lineWidth / 2, 0);
+    context.lineTo(x + context.lineWidth / 2, canvas.height);
+    context.stroke();
+  }
+  for (let y = position[1]; y < canvas.height; y += size[1]) {
+    context.beginPath();
+    context.moveTo(0, y + context.lineWidth / 2);
+    context.lineTo(canvas.width, y + context.lineWidth / 2);
+    context.stroke();
+  }
+
+  const gridImage = document.createElement("img");
+  gridImage.alt = "";
+  gridImage.src = canvas.toDataURL("image/png");
+  Object.assign(gridImage.style, {
+    height: "100%",
+    left: "0",
+    pointerEvents: "none",
+    position: "absolute",
+    top: "0",
+    width: "100%",
+    zIndex: "0",
+  });
+  slideRoot.insertBefore(gridImage, slideRoot.firstChild);
+  slideRoot.style.backgroundImage = "none";
+  slideRoot.style.backgroundSize = "auto";
+  slideRoot.style.backgroundPosition = "0 0";
+  slideRoot.style.backgroundRepeat = "no-repeat";
+}
+
 export async function buildDeckPptxBlob(
   deckTitle: string,
   slides: PptxExportSlide[],
@@ -341,6 +429,7 @@ export async function buildDeckPptxBlob(
         height: dims.height,
       });
       exportClones.push(clone);
+      materializeImportedBackgroundGrid(clone.element);
       widenNoWrapTextElements(clone.element);
       await replaceInlineSvgsWithImages(clone.element);
       await preloadImagesWithCors(clone.element);

package/corpus/templates/slides/app/lib/import-uploaded-deck.ts

@@ -0,0 +1,89 @@
+import { callAction } from "@agent-native/core/client/hooks";
+
+import type { UploadedFile } from "@/components/editor/PromptDialog";
+
+export type ImportedSourceDeck = {
+  file: UploadedFile;
+  format: "pdf" | "pptx";
+  slideCount: number;
+  imagesSkipped: number;
+};
+
+function sourceFormat(file: UploadedFile): "pdf" | "pptx" | null {
+  const name = file.originalName.toLowerCase();
+  if (name.endsWith(".pptx")) return "pptx";
+  if (name.endsWith(".pdf")) return "pdf";
+  return null;
+}
+
+function actionResultRecord(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("The uploaded presentation import returned no result.");
+  }
+  return value as Record<string, unknown>;
+}
+
+/**
+ * Imports the user's source deck into the already-persisted target deck before
+ * the agent run starts. This keeps the agent on the source slide IDs and
+ * preserves source-native images instead of asking it to reconstruct a deck
+ * from extracted text.
+ */
+export async function importUploadedDeckIntoDeck(
+  files: UploadedFile[],
+  deckId: string,
+): Promise<ImportedSourceDeck | null> {
+  const deckFiles = files.filter((file) => sourceFormat(file));
+  if (deckFiles.length === 0) return null;
+  if (deckFiles.length > 1) {
+    throw new Error(
+      "Upload one presentation at a time when asking Slides to improve it. Multiple source decks cannot be merged safely without losing slide order or content.",
+    );
+  }
+
+  const file = deckFiles[0];
+  if (!file) return null;
+  const format = sourceFormat(file);
+  if (!format) return null;
+
+  const result = actionResultRecord(
+    await callAction(
+      format === "pptx" ? "import-pptx" : "import-file",
+      format === "pptx"
+        ? { filePath: file.path, deckId }
+        : {
+            filePath: file.path,
+            format: "pdf",
+            deckId,
+            importIntoDeck: true,
+          },
+    ),
+  );
+  if (result.imported !== true || result.deckId !== deckId) {
+    throw new Error(
+      `The ${format.toUpperCase()} source deck was not imported into the target deck, so no source-preserving improvement was started.`,
+    );
+  }
+
+  const slideCount = result.slideCount;
+  if (typeof slideCount !== "number" || !Number.isInteger(slideCount)) {
+    throw new Error(
+      `The ${format.toUpperCase()} import did not report a reliable slide count, so no source-preserving improvement was started.`,
+    );
+  }
+  if (slideCount < 1) {
+    throw new Error(
+      `The ${format.toUpperCase()} source deck contained no importable slides.`,
+    );
+  }
+
+  const imagesSkipped =
+    typeof result.imagesSkipped === "number" ? result.imagesSkipped : 0;
+  if (imagesSkipped > 0) {
+    throw new Error(
+      `The ${format.toUpperCase()} source deck could not preserve ${imagesSkipped} image(s), so Slides stopped before restyling it. Re-export the deck with browser-renderable images, or upload a PDF for source-faithful page preservation.`,
+    );
+  }
+
+  return { file, format, slideCount, imagesSkipped };
+}

package/corpus/templates/slides/app/lib/slide-animation-elements.ts

@@ -118,6 +118,9 @@ export function animationElementKey(path: number[]): string {
 }
 
 export function findLegacyAnimationContainer(root: Element): Element | null {
+  const marked = root.querySelector(".fmd-animation-container");
+  if (marked && marked.children.length >= 1) return marked;
+
   const children = Array.from(root.children);
   for (let i = children.length - 1; i >= 0; i--) {
     if (children[i].children.length >= 2) return children[i];