@agent-native/core 0.155.0 → 0.157.1

package/corpus/templates/slides/app/components/editor/SlideContextToolbar.tsx

@@ -926,7 +926,7 @@ export function SlideContextToolbar({
       )}
       {zoomControls && (
         <>
-          <div className={TOOLBAR_DIVIDER} />
+          <div className={cn(TOOLBAR_DIVIDER, "ml-auto")} />
           <Tooltip>
             <TooltipTrigger asChild>
               <Button

package/corpus/templates/slides/app/context/DeckContext.tsx

@@ -217,13 +217,18 @@ interface DeckContextType {
   ) => void;
   reloadDecks: () => Promise<void>;
   reloadDecksWithStatus: () => Promise<DeckReloadStatus>;
-  refreshOpenDeck: (deckId: string) => Promise<Deck | null>;
+  refreshOpenDeck: (
+    deckId: string,
+    options?: { clearPendingWrites?: boolean },
+  ) => Promise<Deck | null>;
   getDeck: (id: string) => Deck | undefined;
   addSlide: (
     deckId: string,
     layout?: SlideLayout,
     afterIndex?: number,
+    options?: { persistence?: "debounced" | "immediate" },
   ) => string;
+  flushDeckSave: (deckId: string) => Promise<void>;
   updateSlide: (
     deckId: string,
     slideId: string,
@@ -310,6 +315,8 @@ function normalizeActionDeck(value: unknown): Deck | null {
 const pendingSaves = new Map<string, ReturnType<typeof setTimeout>>();
 const inFlightSaves = new Set<string>();
 const inFlightSaveChains = new Map<string, Promise<void>>();
+const inFlightSaveControllers = new Map<string, AbortController>();
+const deckSaveGenerations = new Map<string, number>();
 const immediateFlushRequests = new Set<string>();
 const deckSaveRetryAttempts = new Map<string, number>();
 const failedSaveDecks = new Set<string>();
@@ -401,7 +408,11 @@ function deckPayload(deck: Deck): Record<string, unknown> {
  * the `save-deck` action is called first, then any trailing granular ops are
  * sent through `patch-deck`.
  */
-async function persistDeckOps(deckId: string, ops: GranularOp[]) {
+async function persistDeckOps(
+  deckId: string,
+  ops: GranularOp[],
+  signal?: AbortSignal,
+) {
   if (ops[0].op === "full-replace") {
     // Legacy full-deck write — used by undo/redo and setDeckSlides.
     // `callAction` bounds it so a stalled save can't wedge `inFlightSaves`
@@ -411,20 +422,28 @@ async function persistDeckOps(deckId: string, ops: GranularOp[]) {
     await callAction(
       "save-deck",
       { deckId, deck: deckPayload(deck) },
-      { method: "PUT" },
+      { method: "PUT", signal },
     );
     const trailingOps = ops.slice(1) as PatchDeckOp[];
     if (trailingOps.length > 0) {
-      await callAction("patch-deck", {
-        deckId,
-        operations: trailingOps,
-      });
+      await callAction(
+        "patch-deck",
+        {
+          deckId,
+          operations: trailingOps,
+        },
+        { signal },
+      );
     }
   } else {
-    await callAction("patch-deck", {
-      deckId,
-      operations: ops as PatchDeckOp[],
-    });
+    await callAction(
+      "patch-deck",
+      {
+        deckId,
+        operations: ops as PatchDeckOp[],
+      },
+      { signal },
+    );
   }
 }
 
@@ -453,15 +472,23 @@ function drainPendingDeckOps(deckId: string): Promise<void> {
     return Promise.resolve();
   }
 
+  const generation = deckSaveGenerations.get(deckId) ?? 0;
+  const controller =
+    typeof AbortController === "undefined" ? null : new AbortController();
+  if (controller) inFlightSaveControllers.set(deckId, controller);
   inFlightSaves.add(deckId);
-  let succeeded = false;
-  const next = persistDeckOps(deckId, ops)
+  const isCurrentGeneration = () =>
+    (deckSaveGenerations.get(deckId) ?? 0) === generation;
+  const next = persistDeckOps(deckId, ops, controller?.signal)
     .then(() => {
-      succeeded = true;
+      if (!isCurrentGeneration()) return;
       deckSaveRetryAttempts.delete(deckId);
       failedSaveDecks.delete(deckId);
     })
     .catch((err) => {
+      // A restore or delete invalidated this request. Its result must not
+      // resurrect the old queue or schedule a retry after the boundary.
+      if (!isCurrentGeneration()) return;
       console.error(`Failed to save deck ${deckId}:`, err);
       const pending = pendingOpsQueue.get(deckId) ?? [];
       pendingOpsQueue.set(deckId, [...ops, ...pending]);
@@ -486,10 +513,13 @@ function drainPendingDeckOps(deckId: string): Promise<void> {
     .finally(() => {
       if (inFlightSaveChains.get(deckId) === next) {
         inFlightSaveChains.delete(deckId);
+        if (controller && inFlightSaveControllers.get(deckId) === controller) {
+          inFlightSaveControllers.delete(deckId);
+        }
         inFlightSaves.delete(deckId);
         const flushImmediately = immediateFlushRequests.delete(deckId);
         notifySaveListeners();
-        if (succeeded && flushImmediately) {
+        if (flushImmediately) {
           void drainPendingDeckOps(deckId);
         }
       }
@@ -499,6 +529,39 @@ function drainPendingDeckOps(deckId: string): Promise<void> {
   return next;
 }
 
+/**
+ * Wait for a deck's in-flight save(s) to fully settle, including any
+ * follow-up drain chained by immediateFlushRequests for ops queued while a
+ * save was already running, and any requeued retry after a failed attempt.
+ * Used when a caller must not proceed (e.g. firing an agent request against
+ * a slide or restoring a saved version) until every write issued before that
+ * boundary has reached the server. Throws if the save ultimately fails after
+ * retries exhaust, since `drainPendingDeckOps` swallows save errors internally
+ * to drive its own retry loop and its promise always resolves regardless of
+ * outcome.
+ */
+async function flushDeckSave(deckId: string): Promise<void> {
+  while (true) {
+    const active = inFlightSaveChains.get(deckId);
+    if (active) {
+      await active;
+      continue;
+    }
+    if (failedSaveDecks.has(deckId)) {
+      throw new Error(
+        `Failed to save deck ${deckId} after ${MAX_DECK_SAVE_RETRIES} attempts`,
+      );
+    }
+    if (pendingOpsQueue.has(deckId) || pendingSaves.has(deckId)) {
+      // A failed op was requeued for retry, or a debounced save is armed;
+      // wait for it to actually run rather than declaring success early.
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      continue;
+    }
+    return;
+  }
+}
+
 function enqueueDeckOp(
   deckId: string,
   op: GranularOp,
@@ -613,6 +676,8 @@ function flushPendingSaves() {
 }
 
 function discardPendingDeckOps(deckId: string) {
+  deckSaveGenerations.set(deckId, (deckSaveGenerations.get(deckId) ?? 0) + 1);
+  inFlightSaveControllers.get(deckId)?.abort();
   const timer = pendingSaves.get(deckId);
   if (timer) clearTimeout(timer);
   pendingSaves.delete(deckId);
@@ -1320,7 +1385,15 @@ export function DeckProvider({ children }: { children: ReactNode }) {
    * this, chat-driven edits land in the editor with Undo disabled.
    */
   const applyRemoteDeckUpdate = useCallback(
-    (updated: Deck, label = "Agent edit") => {
+    (
+      updated: Deck,
+      label = "Agent edit",
+      options?: { clearPendingWrites?: boolean },
+    ) => {
+      if (options?.clearPendingWrites) {
+        discardPendingDeckOps(updated.id);
+        dirtyDeckIdsRef.current.delete(updated.id);
+      }
       const before = decksRef.current.find((d) => d.id === updated.id);
       if (
         before &&
@@ -1413,7 +1486,10 @@ export function DeckProvider({ children }: { children: ReactNode }) {
   //   - Dirty deck / unsaved local create → additive merge only: surface
   //     agent-added slides without ever overwriting or dropping local slides.
   const refetchOpenDeckIfChanged = useCallback(
-    async (currentOpenId: string): Promise<Deck | null> => {
+    async (
+      currentOpenId: string,
+      options?: { clearPendingWrites?: boolean },
+    ): Promise<Deck | null> => {
       const requestId =
         (openDeckRequestIdByDeckRef.current.get(currentOpenId) ?? 0) + 1;
       openDeckRequestIdByDeckRef.current.set(currentOpenId, requestId);
@@ -1425,6 +1501,13 @@ export function DeckProvider({ children }: { children: ReactNode }) {
       // still-pending create — nothing authoritative to reconcile.
       if (!serverDeck) return null;
       const clientDeck = decksRef.current.find((d) => d.id === currentOpenId);
+      if (options?.clearPendingWrites) {
+        lastExternalUpdateRef.current = Date.now();
+        applyRemoteDeckUpdate(serverDeck, "Deck restored", {
+          clearPendingWrites: true,
+        });
+        return serverDeck;
+      }
 
       const hasLocalEdits =
         pendingCreateIdsRef.current.has(currentOpenId) ||
@@ -2095,7 +2178,12 @@ export function DeckProvider({ children }: { children: ReactNode }) {
   );
 
   const addSlide = useCallback(
-    (deckId: string, layout: SlideLayout = "content", afterIndex?: number) => {
+    (
+      deckId: string,
+      layout: SlideLayout = "content",
+      afterIndex?: number,
+      addOptions?: { persistence?: "debounced" | "immediate" },
+    ) => {
       markDeckDirty(deckId);
       const newSlide: Slide = {
         id: nanoid(8),
@@ -2128,7 +2216,7 @@ export function DeckProvider({ children }: { children: ReactNode }) {
         afterSlideId,
         fields: addSlideFields(newSlide),
       };
-      enqueueDeckOp(deckId, op);
+      enqueueDeckOp(deckId, op, addOptions);
       if (before) recordUndo(before, op, { label: "Add slide" });
 
       return newSlide.id;
@@ -2329,6 +2417,7 @@ export function DeckProvider({ children }: { children: ReactNode }) {
         refreshOpenDeck: refetchOpenDeckIfChanged,
         getDeck,
         addSlide,
+        flushDeckSave,
         updateSlide,
         deleteSlide,
         duplicateSlide,

package/corpus/templates/slides/app/global.css

@@ -290,53 +290,20 @@ button[title="Open agent sidebar"] {
 
 .deck-editor-context-toolbar-host--narrow {
   display: flex;
-  justify-content: flex-end;
+  justify-content: flex-start;
 }
 
 .deck-editor-context-toolbar-host--narrow
   > [data-slide-inline-edit-surface="true"] {
   min-width: 0;
-  width: fit-content;
-  max-width: 100%;
-  flex: 0 1 auto;
-}
-
-@container deck-editor (max-width: 1149px) {
-  .deck-editor-context-toolbar-host--wide {
-    display: none;
-  }
-
-  .deck-editor-context-toolbar-host--narrow {
-    display: flex;
-  }
+  width: 100%;
+  flex: 1 1 auto;
 }
 
-@container deck-editor (min-width: 1150px) {
-  .deck-editor-context-toolbar-host--narrow {
-    display: none;
-  }
-
-  .deck-editor-context-toolbar-host--wide[data-context-toolbar-visible="true"] {
-    display: flex;
-    flex: 1 1 0%;
-    align-items: center;
-    justify-content: flex-end;
-  }
-
-  .deck-editor-context-toolbar-host--wide
-    > [data-slide-inline-edit-surface="true"] {
-    min-width: 0;
-    max-width: 100%;
-  }
-
-  .deck-editor-context-toolbar-host--wide .slide-context-toolbar--top-row {
-    height: 2.75rem;
-    justify-content: flex-end;
-    border: 0;
-    background: transparent;
-    padding-inline: 0;
-  }
-}
+/* The element-controls toolbar (New Slide, text/style controls, zoom)
+ * always renders as its own row below the title/Share/Present bar, at every
+ * viewport size — the "wide" host above stays permanently hidden by the
+ * base rule so the row never merges into the title bar on large screens. */
 
 @container (max-width: 36rem) {
   .deck-grid {

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

@@ -514,11 +514,15 @@ const messages = {
     generatingSlide: "Generating slide",
     uploadFailed: "Upload failed",
     uploadAttachedFileFailed: "Could not upload the attached file.",
+    newSlideSaveFailed: "Couldn't save the new slide. Please try again.",
     addSlides: "Add slides",
     addEmptySlide: "Add empty slide",
     noAi: "no AI",
     duplicateCurrentSlide: "Duplicate current slide",
     promptPlaceholder: "Describe the slides you want...",
+    newSlide: "New slide",
+    closeAddSlides: "Close",
+    describeThisSlide: "Describe this slide",
   },
   presentation: {
     loadFailed: "Could not load this presentation.",

package/corpus/templates/slides/app/lib/editor-shortcuts.ts

@@ -0,0 +1,46 @@
+interface EditorShortcutEvent {
+  key: string;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  shiftKey: boolean;
+  repeat: boolean;
+  isComposing: boolean;
+  target: EventTarget | null;
+}
+
+function isEditableSurface(target: EventTarget | null): boolean {
+  return (
+    target instanceof HTMLElement &&
+    (target.closest(
+      "input, textarea, select, [contenteditable='true'], [role='textbox']",
+    ) !== null ||
+      target.isContentEditable)
+  );
+}
+
+export function shouldStopSlidesItalicShortcut(event: EditorShortcutEvent) {
+  if (
+    event.repeat ||
+    event.isComposing ||
+    event.key.toLowerCase() !== "i" ||
+    event.altKey ||
+    event.shiftKey ||
+    !(event.ctrlKey || event.metaKey)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+export function isSlidesItalicEditableTarget(event: EditorShortcutEvent) {
+  return isEditableSurface(event.target);
+}
+
+export function shouldSuppressSlidesItalicShortcut(event: EditorShortcutEvent) {
+  return (
+    shouldStopSlidesItalicShortcut(event) &&
+    !isSlidesItalicEditableTarget(event)
+  );
+}

package/corpus/templates/slides/app/pages/DeckEditor.tsx

@@ -76,6 +76,7 @@ import {
   shouldShowDeckEditorSkeleton,
 } from "@/lib/deck-editor-loading";
 import { getPreset } from "@/lib/design-systems";
+import { shouldSuppressSlidesItalicShortcut } from "@/lib/editor-shortcuts";
 import { exportDeckToGoogleSlides } from "@/lib/export-google-slides-client";
 import { exportDeckAsPdf } from "@/lib/export-pdf-client";
 import { exportDeckAsPptx } from "@/lib/export-pptx-client";
@@ -182,6 +183,7 @@ export default function DeckEditor() {
     duplicateSlide,
     duplicateDeck,
     addSlide,
+    flushDeckSave,
     reorderSlides,
     markDeckDirty,
     undo,
@@ -218,6 +220,25 @@ export default function DeckEditor() {
     pendingDeckNavigationBlocker.proceed();
   }, [pendingDeckNavigationBlocker]);
   const { generating } = useAgentGenerating();
+  // Dedicated instance (not the `generating` one above, which reflects ANY
+  // agent chat activity) so an unrelated concurrent run can't be mistaken
+  // for this one finishing and clear the flag early. Owning the submit call
+  // here — instead of in EditorSidebar, which unmounts when the rail closes
+  // on narrow viewports — keeps both the run-scoping and the completion
+  // tracking correct across a remount.
+  const { generating: addSlideAgentGenerating, submit: addSlideAgentSubmit } =
+    useAgentGenerating();
+  const sawAddSlideAgentGeneratingRef = useRef(false);
+  useEffect(() => {
+    if (addSlideAgentGenerating) {
+      sawAddSlideAgentGeneratingRef.current = true;
+      return;
+    }
+    if (addSlideGenerating && sawAddSlideAgentGeneratingRef.current) {
+      sawAddSlideAgentGeneratingRef.current = false;
+      setAddSlideGenerating(false);
+    }
+  }, [addSlideGenerating, addSlideAgentGenerating]);
   // Generation intent can arrive after this route mounts because the user
   // answers pre-generation questions from the empty editor.
   const wasNewDeckCreation = useRef(searchParams.get("generating") === "1");
@@ -231,6 +252,14 @@ export default function DeckEditor() {
   const [sidebarOpen, setSidebarOpen] = useState(
     () => typeof window !== "undefined" && window.innerWidth >= 768,
   );
+  // The slide just inserted via the toolbar's New Slide button, so the rail
+  // can anchor the "describe this slide" popover to its thumbnail once it
+  // mounts — even though the button that sets this now lives in the
+  // toolbar, outside the rail.
+  const [describeSlideId, setDescribeSlideId] = useState<string | null>(null);
+  useEffect(() => {
+    setDescribeSlideId(null);
+  }, [id]);
   const [contextToolbarSlot, setContextToolbarSlot] =
     useState<HTMLDivElement | null>(null);
   const [wideContextToolbarSlot, setWideContextToolbarSlot] =
@@ -756,6 +785,18 @@ export default function DeckEditor() {
       document.removeEventListener("keydown", handleTextToolShortcut);
   }, [canEdit]);
 
+  useEffect(() => {
+    const handleItalicShortcut = (event: KeyboardEvent) => {
+      if (!shouldSuppressSlidesItalicShortcut(event)) return;
+      event.preventDefault();
+      event.stopImmediatePropagation();
+    };
+
+    document.addEventListener("keydown", handleItalicShortcut, true);
+    return () =>
+      document.removeEventListener("keydown", handleItalicShortcut, true);
+  }, []);
+
   // Delete key deletes the current slide
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
@@ -807,49 +848,92 @@ export default function DeckEditor() {
     return () => document.removeEventListener("keydown", handleKeyDown);
   }, [deck, id, activeSlideId, deleteSlideWithUndo, pinMode, drawMode]);
 
-  // Cmd/Ctrl+C then Cmd/Ctrl+V duplicates a slide thumbnail in the film
-  // strip. Scoped to an actually-focused thumbnail (rather than "no other
-  // handler claimed it", like the Delete-key handler below) so the shortcut
-  // can't fire from an unrelated toolbar button, dialog, or menu.
+  // Command/Ctrl+C then Command/Ctrl+V on the slide rail duplicates the
+  // selected slide directly below itself. Only claims the shortcut when no
+  // slide element is selected — SlideEditor owns Cmd+C/V for object copy/paste
+  // in that case.
   const copiedSlideIdRef = useRef<string | null>(null);
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
-      if (!deck || !id) return;
+      if (!deck || !id || !canEdit) return;
       if (!(e.metaKey || e.ctrlKey) || e.altKey) return;
       const key = e.key.toLowerCase();
       if (key !== "c" && key !== "v") return;
       if (pinMode || drawMode) return;
+
+      // A live browser text selection (e.g. the user triple-clicked rendered,
+      // non-editable slide copy) means Cmd/Ctrl+C is a normal text copy —
+      // let it through instead of hijacking it into a slide duplicate.
+      if (key === "c" && (window.getSelection()?.toString().length ?? 0) > 0) {
+        return;
+      }
+
+      // Radix Popper positions Popover/DropdownMenu/Select/Tooltip content
+      // inside the same [data-radix-popper-content-wrapper]. A tooltip opens
+      // on plain hover, so treating every such wrapper as blocking would
+      // disable this shortcut just by mousing over a toolbar button; only
+      // wrappers that aren't tooltips (marked with data-agent-native-tooltip)
+      // should count as an open menu/popover/dialog owning the keystroke.
+      const isBlockingPopperWrapper = (el: Element) =>
+        el.matches("[data-radix-popper-content-wrapper]") &&
+        !el.querySelector("[data-agent-native-tooltip]");
+      const isInsideSafeZone = (el: Element | null) => {
+        if (!el) return false;
+        if (el instanceof HTMLInputElement) return true;
+        if (el instanceof HTMLTextAreaElement) return true;
+        if (el instanceof HTMLElement) {
+          if (el.isContentEditable) return true;
+          if (el.closest("[contenteditable='true']")) return true;
+          if (el.closest("input, textarea, [role='textbox']")) return true;
+          if (el.closest("[data-pin-popover]")) return true;
+          if (el.closest("[data-add-slide-popover]")) return true;
+          if (el.closest(".agent-panel-root")) return true;
+          if (el.closest("[role='dialog'], [role='alertdialog']")) return true;
+          const popperWrapper = el.closest(
+            "[data-radix-popper-content-wrapper]",
+          );
+          if (popperWrapper && isBlockingPopperWrapper(popperWrapper))
+            return true;
+        }
+        return false;
+      };
+      if (isInsideSafeZone(e.target as Element | null)) return;
+      if (isInsideSafeZone(document.activeElement)) return;
+      if (document.querySelector("[data-pin-popover]")) return;
+      if (document.querySelector("[data-add-slide-popover]")) return;
+      // A dialog/sheet/menu/popover owning focus elsewhere in the DOM (not
+      // just under the event target) still shouldn't let this document-level
+      // shortcut duplicate the slide underneath it.
       if (
         document.querySelector(
-          "[role='dialog'], [role='menu'], [role='listbox']",
+          "[role='dialog'], [role='alertdialog'], [role='menu'], [role='listbox']",
         )
-      ) {
+      )
+        return;
+      if (
+        Array.from(
+          document.querySelectorAll("[data-radix-popper-content-wrapper]"),
+        ).some(isBlockingPopperWrapper)
+      )
+        return;
+      if (document.querySelector("[data-slide-element-selected='true']"))
         return;
-      }
-      if (!canEdit) return;
-      const focusedThumbnail = document.activeElement?.closest(
-        "[data-slide-thumbnail-id]",
-      );
-      if (!focusedThumbnail) return;
-      const focusedSlideId = focusedThumbnail.getAttribute(
-        "data-slide-thumbnail-id",
-      );
-      if (!focusedSlideId) return;
 
       if (key === "c") {
-        copiedSlideIdRef.current = focusedSlideId;
+        if (!activeSlideId) return;
+        copiedSlideIdRef.current = activeSlideId;
         return;
       }
-      const copiedSlideId = copiedSlideIdRef.current;
-      if (!copiedSlideId) return;
-      if (!deck.slides.some((s) => s.id === copiedSlideId)) return;
+
+      const copiedId = copiedSlideIdRef.current;
+      if (!copiedId || !deck.slides.some((s) => s.id === copiedId)) return;
       e.preventDefault();
-      const newSlideId = duplicateSlide(id, copiedSlideId);
-      if (newSlideId) setActiveSlideId(newSlideId);
+      const newId = duplicateSlide(id, copiedId);
+      if (newId) setActiveSlideId(newId);
     };
     document.addEventListener("keydown", handleKeyDown);
     return () => document.removeEventListener("keydown", handleKeyDown);
-  }, [deck, id, duplicateSlide, canEdit, pinMode, drawMode]);
+  }, [deck, id, canEdit, activeSlideId, duplicateSlide, pinMode, drawMode]);
 
   // Resolve the active slide from URL/deck state. Imports replace slide IDs, so
   // keep this valid after deck contents change instead of only on first load.
@@ -1083,9 +1167,30 @@ export default function DeckEditor() {
 
   const handleAddEmptySlide = () => {
     const activeIdx = deck.slides.findIndex((s) => s.id === activeSlideId);
-    setActiveSlideId(
-      addSlide(id, "blank", activeIdx >= 0 ? activeIdx : undefined),
+    // Immediate persistence: this placeholder is immediately followed by an
+    // agent request to `update-slide` it, which can reach the server before
+    // the default 500ms debounce would have flushed the `add-slide` op.
+    const newId = addSlide(
+      id,
+      "blank",
+      activeIdx >= 0 ? activeIdx : undefined,
+      {
+        persistence: "immediate",
+      },
     );
+    setActiveSlideId(newId);
+    return newId;
+  };
+
+  const handleNewSlideClick = () => {
+    const newId = handleAddEmptySlide();
+    if (newId) {
+      // The rail owns the anchor node the describe-slide popover attaches
+      // to, so it must be mounted even if it started closed on a narrow
+      // viewport where the toolbar button is still reachable.
+      setSidebarOpen(true);
+      setDescribeSlideId(newId);
+    }
   };
 
   return (
@@ -1101,7 +1206,6 @@ export default function DeckEditor() {
         canEdit={canEdit}
         canComment={canComment}
         onTitleChange={(title) => updateDeck(id, { title })}
-        slideCount={deck.slides.length}
         currentSlideIndex={currentIndex >= 0 ? currentIndex : 0}
         sidebarOpen={sidebarOpen}
         onToggleSidebar={() => setSidebarOpen(!sidebarOpen)}
@@ -1113,6 +1217,8 @@ export default function DeckEditor() {
         onShowHistory={() => setHistoryOpen((open) => !open)}
         historyButtonRef={historyButtonRef}
         currentSlide={currentSlide}
+        onAddEmptySlide={canEdit ? handleNewSlideClick : undefined}
+        addSlideGenerating={addSlideGenerating}
         onWideContextToolbarSlotChange={setWideContextToolbarSlot}
         activeUsers={slideActiveUsers.filter((u) => u.email !== session?.email)}
         agentPresent={agentPresent}
@@ -1187,13 +1293,6 @@ export default function DeckEditor() {
           }
           return exportDeckToGoogleSlides(deck.title, slides, deck.aspectRatio);
         }}
-        currentSlideId={currentSlide?.id}
-        addSlideGenerating={addSlideGenerating}
-        onAddSlideGeneratingChange={setAddSlideGenerating}
-        onAddEmptySlide={handleAddEmptySlide}
-        onDuplicateCurrentSlide={
-          currentSlide ? () => duplicateSlide(id, currentSlide.id) : undefined
-        }
         onChangeSlideTransition={
           canEdit && currentSlide
             ? (transition) => updateSlide(id, currentSlide.id, { transition })
@@ -1226,6 +1325,13 @@ export default function DeckEditor() {
                   slides={deck.slides}
                   activeSlideId={currentSlide?.id || ""}
                   deckId={id}
+                  deckTitle={deck.title}
+                  describeSlideId={describeSlideId}
+                  onCloseDescribe={() => setDescribeSlideId(null)}
+                  onAwaitAddSlidePersisted={() => flushDeckSave(id)}
+                  onRemoveFailedSlide={(slideId) => deleteSlide(id, slideId)}
+                  addSlideAgentSubmit={addSlideAgentSubmit}
+                  onAddSlideGeneratingChange={setAddSlideGenerating}
                   onSelectSlide={(slideId) => {
                     setGeneratingSlideSelected(false);
                     setActiveSlideId(slideId);
@@ -1304,19 +1410,11 @@ export default function DeckEditor() {
             contextToolbarLeading={
               canEdit ? (
                 <EditorActionCluster
-                  deckId={id}
-                  deckTitle={deck.title}
-                  currentSlideId={currentSlide.id}
-                  slideCount={deck.slides.length}
-                  currentSlideIndex={currentIndex >= 0 ? currentIndex : 0}
-                  addSlideGenerating={addSlideGenerating}
-                  onAddSlideGeneratingChange={setAddSlideGenerating}
-                  onAddEmptySlide={handleAddEmptySlide}
-                  onDuplicateCurrentSlide={() =>
-                    duplicateSlide(id, currentSlide.id)
-                  }
                   textBoxMode={textBoxMode}
                   onToggleTextBoxMode={toggleTextBoxMode}
+                  onAddEmptySlide={handleNewSlideClick}
+                  addSlideGenerating={addSlideGenerating}
+                  currentSlideId={currentSlide.id}
                   slideTransition={currentSlide.transition}
                   onChangeSlideTransition={(transition) =>
                     updateSlide(id, currentSlide.id, { transition })

package/dist/agent/index.d.ts

@@ -1,4 +1,4 @@
-export { createProductionAgentHandler, type ActionEntry, type ScriptEntry, type ProductionAgentOptions, type AgentLoopFinalResponseGuard, type AgentLoopFinalResponseGuardContext, type AgentLoopFinalResponseGuardResult, type AgentLoopToolCallSummary, type AgentLoopToolResultSummary, } from "./production-agent.js";
+export { createProductionAgentHandler, type ActionEntry, type ScriptEntry, type ProductionAgentOptions, type AgentActionSurface, type AgentActionSurfaceDetails, type AgentLoopFinalResponseGuard, type AgentLoopFinalResponseGuardContext, type AgentLoopFinalResponseGuardResult, type AgentLoopToolCallSummary, type AgentLoopToolResultSummary, } from "./production-agent.js";
 export { type ActionTool, type ScriptTool, type AgentMessage, type AgentChatRequest, type AgentChatEvent, type AgentChatAttachment, type AgentChatReference, type MentionProvider, type MentionProviderItem, } from "./types.js";
 export { TripWire, type Processor, type ProcessorState, type ProcessorAbort, type ProcessOutputStreamArgs, type ProcessOutputStepArgs, type ProcessOutputResultArgs, } from "./processors.js";
 export { DEFAULT_MODEL } from "./default-model.js";