@agent-native/core-corpus 0.213.1 → 0.216.0

package/corpus/templates/slides-2/actions/get-layout-overflows.ts

@@ -0,0 +1,192 @@
+import { defineAction } from "@agent-native/core/action";
+import { resolveAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import { appStateKey } from "../shared/app-state-tabs.js";
+import {
+  slideFitMeasurementMatchesSlide,
+  type DeckFitState,
+} from "../shared/slide-fit.js";
+import { assertSlides2DeckData } from "./_deck-app-scope.js";
+import { readAppStateForCurrentTab } from "./_tab-state.js";
+
+type CurrentSlideFitMeasurement = DeckFitState["slides"][string] & {
+  slideId: string;
+};
+
+function getCurrentSlideFitMeasurement(
+  value: unknown,
+  slide: { id: string; content?: string; layoutFitRevision?: string },
+  deckId: string,
+): CurrentSlideFitMeasurement | null {
+  if (!value || typeof value !== "object") return null;
+
+  const measurement = value as Record<string, unknown>;
+  const slideId = measurement.slideId;
+  const measurementDeckId = measurement.deckId;
+  const contentHash = measurement.contentHash;
+  const contentHeight = measurement.contentHeight;
+  const contentWidth = measurement.contentWidth;
+  const viewportHeight = measurement.viewportHeight;
+  const viewportWidth = measurement.viewportWidth;
+  const verticalOverflow = measurement.verticalOverflow;
+  const horizontalOverflow = measurement.horizontalOverflow;
+  const measuredAt = measurement.measuredAt;
+  const layoutFitRevision = measurement.layoutFitRevision;
+
+  if (
+    typeof slideId !== "string" ||
+    slideId !== slide.id ||
+    (measurementDeckId !== undefined && measurementDeckId !== deckId) ||
+    typeof contentHash !== "string" ||
+    (layoutFitRevision !== undefined &&
+      typeof layoutFitRevision !== "string") ||
+    !slideFitMeasurementMatchesSlide(
+      {
+        contentHash,
+        ...(typeof layoutFitRevision === "string" ? { layoutFitRevision } : {}),
+      },
+      slide,
+    ) ||
+    typeof contentHeight !== "number" ||
+    !Number.isFinite(contentHeight) ||
+    typeof contentWidth !== "number" ||
+    !Number.isFinite(contentWidth) ||
+    typeof viewportHeight !== "number" ||
+    !Number.isFinite(viewportHeight) ||
+    typeof viewportWidth !== "number" ||
+    !Number.isFinite(viewportWidth) ||
+    typeof verticalOverflow !== "number" ||
+    !Number.isFinite(verticalOverflow) ||
+    typeof horizontalOverflow !== "number" ||
+    !Number.isFinite(horizontalOverflow) ||
+    typeof measuredAt !== "number" ||
+    !Number.isFinite(measuredAt)
+  ) {
+    return null;
+  }
+
+  return {
+    slideId,
+    contentHash,
+    ...(typeof layoutFitRevision === "string" ? { layoutFitRevision } : {}),
+    contentHeight,
+    contentWidth,
+    viewportHeight,
+    viewportWidth,
+    verticalOverflow,
+    horizontalOverflow,
+    measuredAt,
+  };
+}
+
+export default defineAction({
+  readOnly: true,
+  dedupe: false,
+  description:
+    "Read current browser measurements for every slide in a deck. This reads measurements from the open Slides 2 editor tab; it does not start or wait for measurement. Call once after all slide edits and once more only after a repair. If status is unknown, report unknownSlides and do not call again this turn unless the editor has produced a new measurement.",
+  schema: z.object({
+    deckId: z.string().describe("Deck ID"),
+  }),
+  http: false,
+  run: async ({ deckId }) => {
+    const access = await resolveAccess("deck", deckId);
+    if (!access)
+      throw Object.assign(new Error("Deck not found"), { statusCode: 404 });
+
+    assertSlides2DeckData(access.resource.data);
+    const deck = JSON.parse(access.resource.data) as {
+      aspectRatio?: string | null;
+      slides?: Array<{ id: string; content?: string }>;
+    };
+    const slides = Array.isArray(deck.slides) ? deck.slides : [];
+    const state = (await readAppStateForCurrentTab(
+      appStateKey("deck-fit-checks"),
+      { fallbackToGlobal: false },
+    )) as DeckFitState | null;
+    const currentSlideState = await readAppStateForCurrentTab(
+      appStateKey("slide-fit-check"),
+      { fallbackToGlobal: false },
+    );
+
+    const unknownSlides: Array<{ slideId: string; slideNumber: number }> = [];
+    const overflows: Array<{
+      slideId: string;
+      slideNumber: number;
+      verticalOverflow: number;
+      horizontalOverflow: number;
+      contentHeight: number;
+      contentWidth: number;
+      viewportHeight: number;
+      viewportWidth: number;
+      hint: string;
+    }> = [];
+
+    slides.forEach((slide, index) => {
+      const measurement =
+        getCurrentSlideFitMeasurement(currentSlideState, slide, deckId) ??
+        (state?.deckId === deckId &&
+        state.aspectRatio === (deck.aspectRatio ?? "16:9")
+          ? state.slides?.[slide.id]
+          : undefined);
+      if (
+        !measurement ||
+        !slideFitMeasurementMatchesSlide(measurement, slide) ||
+        !Number.isFinite(measurement.verticalOverflow) ||
+        !Number.isFinite(measurement.horizontalOverflow) ||
+        !Number.isFinite(measurement.contentHeight) ||
+        !Number.isFinite(measurement.contentWidth) ||
+        !Number.isFinite(measurement.viewportHeight) ||
+        !Number.isFinite(measurement.viewportWidth) ||
+        !Number.isFinite(measurement.measuredAt)
+      ) {
+        unknownSlides.push({ slideId: slide.id, slideNumber: index + 1 });
+        return;
+      }
+      if (
+        measurement.verticalOverflow > 0 ||
+        measurement.horizontalOverflow > 0
+      ) {
+        overflows.push({
+          slideId: slide.id,
+          slideNumber: index + 1,
+          verticalOverflow: measurement.verticalOverflow,
+          horizontalOverflow: measurement.horizontalOverflow,
+          contentHeight: measurement.contentHeight,
+          contentWidth: measurement.contentWidth,
+          viewportHeight: measurement.viewportHeight,
+          viewportWidth: measurement.viewportWidth,
+          hint: [
+            measurement.verticalOverflow > 0
+              ? `Reduce vertical content by at least ${Math.ceil(measurement.verticalOverflow)} px by splitting dense content, shortening copy, or reducing gaps and padding; keep body text at least 16 px.`
+              : null,
+            measurement.horizontalOverflow > 0
+              ? `Reduce horizontal content by at least ${Math.ceil(measurement.horizontalOverflow)} px by reflowing the layout, wrapping wide content, or reducing horizontal padding while preserving readability.`
+              : null,
+          ]
+            .filter(Boolean)
+            .join(" "),
+        });
+      }
+    });
+
+    const canClaimDeckFits =
+      unknownSlides.length === 0 && overflows.length === 0;
+
+    return {
+      deckId,
+      status: unknownSlides.length > 0 ? "unknown" : "measured",
+      measuredSlideCount: slides.length - unknownSlides.length,
+      slideCount: slides.length,
+      unknownSlides,
+      unknownSlideIds: unknownSlides.map(({ slideId }) => slideId),
+      overflows,
+      canClaimDeckFits,
+      ...(unknownSlides.length > 0
+        ? {
+            guidance: `Slides ${unknownSlides.map(({ slideNumber, slideId }) => `${slideNumber} (${slideId})`).join(", ")} have no current browser measurement. Rechecking in this turn will not change this result unless the editor reports a new measurement.`,
+          }
+        : {}),
+    };
+  },
+});

package/corpus/templates/slides-2/actions/get-slide-render.ts

@@ -0,0 +1,125 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { slideAssetOrigins } from "../server/lib/slide-source.js";
+import { buildReactSlideRuntime } from "../server/lib/slide-worker-runtime.js";
+import { resolveSlideDesignFontAssets } from "../server/lib/uploaded-fonts.js";
+import { readSlideDesignTokens } from "../shared/slide-design-tokens.js";
+import { assertSlides2DeckData } from "./_deck-app-scope.js";
+import {
+  compileSlideSource,
+  readStoredSlideSource,
+  slideSourceFailure,
+} from "./_slide-source.js";
+
+export default defineAction({
+  title: "Render slide source",
+  description:
+    "Return a revision-checked render artifact for a saved React slide. It contains a bounded Worker bundle and validated design, metadata, transition, styles, and uploaded-asset references for rendering in an opaque-origin sandbox; `html` is the derived legacy preview and may be empty for React modules with imports. The artifact includes the source revision/hash and only origins of referenced uploaded assets.",
+  agentTool: false,
+  schema: z.object({
+    deckId: z.string().min(1).describe("Deck containing the slide"),
+    slideId: z.string().min(1).describe("Stable slide ID to render"),
+    expectedRevision: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe("Optional revision the editor expects to render"),
+    expectedSourceHash: z
+      .string()
+      .regex(/^[a-f0-9]{64}$/)
+      .optional()
+      .describe("Optional source hash the editor expects to render"),
+  }),
+  readOnly: true,
+  retrySafe: true,
+  http: { method: "GET" },
+  mcpAnnotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: false,
+  },
+  requiresAuth: false,
+  run: async ({ deckId, slideId, expectedRevision, expectedSourceHash }) => {
+    await assertAccess("deck", deckId, "viewer");
+    const [row] = await getDb()
+      .select({
+        id: schema.decks.id,
+        ownerEmail: schema.decks.ownerEmail,
+        orgId: schema.decks.orgId,
+        data: schema.decks.data,
+      })
+      .from(schema.decks)
+      .where(eq(schema.decks.id, deckId))
+      .limit(1);
+    if (!row)
+      throw slideSourceFailure("Deck not found.", 404, "deck_not_found");
+    const snapshot = readStoredSlideSource(row.data, slideId);
+    assertSlides2DeckData(snapshot.data);
+    if (
+      (expectedRevision !== undefined &&
+        expectedRevision !== snapshot.revision) ||
+      (expectedSourceHash !== undefined &&
+        expectedSourceHash !== snapshot.sourceHash)
+    ) {
+      throw slideSourceFailure(
+        "Slide source changed before it could be rendered.",
+        409,
+        "slide_source_conflict",
+        { revision: snapshot.revision, sourceHash: snapshot.sourceHash },
+      );
+    }
+    const rendered = await compileSlideSource(snapshot.slide.sourceTsx, {
+      ownerEmail: row.ownerEmail,
+      orgId: row.orgId,
+    });
+    if (
+      rendered.sourceHash !== snapshot.sourceHash ||
+      snapshot.slide.content !== rendered.content
+    ) {
+      throw slideSourceFailure(
+        "Stored slide preview does not match its React source.",
+        409,
+        "slide_source_integrity_error",
+      );
+    }
+    const slides = snapshot.data.slides;
+    if (!Array.isArray(slides) || slides.length < 1) {
+      throw slideSourceFailure(
+        "Deck slide ordering is invalid for rendering.",
+        409,
+        "invalid_deck_slide_order",
+      );
+    }
+    const runtime = await buildReactSlideRuntime(snapshot.slide.sourceTsx, {
+      current: snapshot.position + 1,
+      total: slides.length,
+      assetUrls: rendered.assetUrls,
+    });
+    const designTokens = readSlideDesignTokens(snapshot.data);
+    const fontAssets = await resolveSlideDesignFontAssets(designTokens, {
+      deckId,
+      ownerEmail: row.ownerEmail,
+      orgId: row.orgId,
+    });
+    return {
+      protocolVersion: 1,
+      deckId,
+      slideId,
+      revision: snapshot.revision,
+      sourceHash: snapshot.sourceHash,
+      width: 1920,
+      height: 1080,
+      html: rendered.content,
+      assetOrigins: rendered.assetOrigins,
+      fontOrigins: slideAssetOrigins(fontAssets.map((font) => font.url)),
+      fontAssets,
+      designTokens,
+      runtime,
+    };
+  },
+});

package/corpus/templates/slides-2/actions/get-slide-source.ts

@@ -0,0 +1,115 @@
+import { defineAction } from "@agent-native/core";
+import { fail, isActionContractError } from "@agent-native/core/action";
+import { assertAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { hashSlideSource } from "../server/lib/slide-source.js";
+import { assertSlides2DeckData } from "./_deck-app-scope.js";
+import {
+  canReadPresenterNotes,
+  redactPresenterNotes,
+} from "./_presenter-notes.js";
+import { readStoredSlideSource } from "./_slide-source.js";
+
+function rethrowSlideSourceFailure(error: unknown): never {
+  if (isActionContractError(error)) throw error;
+  if (!(error instanceof Error)) throw error;
+  const failure = error as Error & {
+    statusCode?: unknown;
+    errorCode?: unknown;
+    details?: unknown;
+  };
+  if (
+    typeof failure.statusCode !== "number" ||
+    typeof failure.errorCode !== "string"
+  ) {
+    throw error;
+  }
+  const details =
+    failure.details &&
+    typeof failure.details === "object" &&
+    !Array.isArray(failure.details)
+      ? (failure.details as Record<string, unknown>)
+      : undefined;
+  fail(error.message, {
+    statusCode: failure.statusCode,
+    errorCode: failure.errorCode,
+    ...(details ? { details } : {}),
+  });
+}
+
+export default defineAction({
+  title: "Read slide source",
+  description:
+    "Read one slide's React TSX source, source revision, hash, deck title, and position. Use this before editing a slide source or resolving a revision conflict.",
+  schema: z.object({
+    deckId: z.string().min(1).describe("Deck containing the slide"),
+    slideId: z.string().min(1).describe("Stable slide ID to read"),
+  }),
+  readOnly: true,
+  retrySafe: true,
+  http: { method: "GET" },
+  mcpAnnotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: false,
+  },
+  run: async ({ deckId, slideId }) => {
+    const access = await assertAccess("deck", deckId, "viewer");
+    const [row] = await getDb()
+      .select({
+        id: schema.decks.id,
+        title: schema.decks.title,
+        data: schema.decks.data,
+      })
+      .from(schema.decks)
+      .where(eq(schema.decks.id, deckId))
+      .limit(1);
+    if (!row) {
+      fail("Deck not found.", {
+        statusCode: 404,
+        errorCode: "deck_not_found",
+      });
+    }
+    let snapshot: ReturnType<typeof readStoredSlideSource>;
+    try {
+      snapshot = readStoredSlideSource(row.data, slideId);
+    } catch (error) {
+      rethrowSlideSourceFailure(error);
+    }
+    assertSlides2DeckData(snapshot.data);
+    const canReadNotes = canReadPresenterNotes(access.role);
+    const visibleSlide = canReadNotes
+      ? snapshot.slide
+      : (redactPresenterNotes(snapshot.slide) as Record<string, unknown>);
+    const visibleSourceTsx = visibleSlide.sourceTsx;
+    if (typeof visibleSourceTsx !== "string") {
+      fail("Slide source integrity could not be verified.", {
+        statusCode: 409,
+        errorCode: "slide_source_integrity_error",
+      });
+    }
+    return {
+      deck: { id: row.id, title: row.title },
+      slide: {
+        id: slideId,
+        deckId,
+        position: snapshot.position,
+        sourceTsx: visibleSourceTsx,
+        revision: snapshot.revision,
+        ...(typeof visibleSlide.sourceHash === "string"
+          ? { sourceHash: visibleSlide.sourceHash }
+          : { sourceHash: hashSlideSource(visibleSourceTsx) }),
+        ...(canReadNotes && typeof visibleSlide.notes === "string"
+          ? { notes: visibleSlide.notes }
+          : {}),
+        ...(typeof visibleSlide.transition === "string" ||
+        visibleSlide.transition === null
+          ? { transition: visibleSlide.transition }
+          : {}),
+      },
+    };
+  },
+});

package/corpus/templates/slides-2/actions/get-slide-theme-preview.ts

@@ -0,0 +1,64 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { hashSlideSource } from "../server/lib/slide-source.js";
+import { getBuiltInSlideThemeDemoSource } from "../server/lib/slide-theme-demo-sources.js";
+import { getBuiltInSlideTheme } from "../server/lib/slide-themes.js";
+import { buildReactSlideRuntime } from "../server/lib/slide-worker-runtime.js";
+
+export default defineAction({
+  title: "Render slide theme preview",
+  description:
+    "Render one built-in theme demo page in the same bounded Worker and opaque-origin iframe used by saved slides. Use the theme gallery's preview for visual selection; this does not create a deck or save slide data.",
+  agentTool: false,
+  schema: z.object({
+    id: z.string().min(1).max(100).describe("Built-in slide theme ID"),
+    pageIndex: z
+      .number()
+      .int()
+      .min(0)
+      .max(2)
+      .describe("Zero-based demo page index: 0, 1, or 2"),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  retrySafe: true,
+  run: async ({ id, pageIndex }) => {
+    const theme = getBuiltInSlideTheme(id);
+    const sourceTsx = getBuiltInSlideThemeDemoSource(id, pageIndex);
+    if (!theme || !sourceTsx) {
+      fail("Slide theme preview not found.", {
+        errorCode: "slide_theme_preview_not_found",
+        statusCode: 404,
+      });
+    }
+
+    const pageCount = 3;
+    const runtime = await buildReactSlideRuntime(sourceTsx, {
+      current: pageIndex + 1,
+      total: pageCount,
+      assetUrls: new Map(),
+    });
+    const slideId = `theme-${id}-${pageIndex}`;
+
+    return {
+      pageIndex,
+      pageCount,
+      artifact: {
+        protocolVersion: 1,
+        deckId: `theme-${id}`,
+        slideId,
+        revision: 1,
+        sourceHash: hashSlideSource(sourceTsx),
+        width: 1920,
+        height: 1080,
+        html: "",
+        assetOrigins: [],
+        fontOrigins: [],
+        fontAssets: [],
+        runtime,
+      },
+      theme: { id: theme.id, name: theme.name },
+    };
+  },
+});

package/corpus/templates/slides-2/actions/get-slide-theme.ts

@@ -0,0 +1,44 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { getBuiltInSlideTheme } from "../server/lib/slide-themes.js";
+
+export default defineAction({
+  description:
+    "Read a bundled slide theme's complete authoring guide with Slides 2 compatibility notes. Treat examples as visual references: keep design type sizes at or below 320px, omit remote font loading, DOM/browser globals and effects, map only supported SQL theme tokens, and store the selected ID in every generated slide's static meta.theme.",
+  schema: z.object({
+    id: z
+      .string()
+      .min(1)
+      .max(100)
+      .describe("Theme ID returned by list-slide-themes"),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async ({ id }) => {
+    const theme = getBuiltInSlideTheme(id);
+    if (!theme) {
+      fail("Slide theme not found.", {
+        errorCode: "slide_theme_not_found",
+        statusCode: 404,
+      });
+    }
+    const compatibilityNotes = [
+      "## Slides 2 runtime and persistence notes",
+      "Treat the following bundled theme guide as a visual reference, not paste-ready Slides 2 source. Put this static export in every generated slide module so the selected theme stays attached to each saved source page:",
+      "```tsx",
+      `export const meta = { theme: ${JSON.stringify(theme.id)} };`,
+      "```",
+      "`create-deck` preserves module-level `meta` exports when it splits a static page array into separate SQL slides. Repeat the export in each `add-slide` source module.",
+      "",
+      "The Worker accepts static `design` values, but `design.typeScale.hero` and `.body` are pixel sizes capped at 320; reduce Aero's 620px hero value before using it. Do not copy Google Fonts URLs or code that inserts `link`/`style` nodes through `document`. Use available system font stacks and static scoped CSS. Do not copy `window`, `document`, `performance`, `requestAnimationFrame`, or effect-driven behavior such as `useEffect`; the Worker renders statically. Use only the supported `Step`, `Steps`, `useSlidePageNumber()`, and `useIsActivePage()` runtime APIs for page/reveal behavior.",
+      "",
+      "Theme guide `design` exports and Slides 2 SQL deck tokens are different contracts. Map `design.palette.bg`, `.text`, and `.accent` to token `background`, `text`, and `accent`. Choose token fonts from Arial, Courier New, Georgia, Helvetica, system-ui, Times New Roman, Trebuchet MS, or Verdana; the guide's Barlow, Inter, Newsreader, Gabarito, and DM Mono families cannot be saved as SQL font tokens. `design.typeScale` values are pixels, while SQL `heroScale` and `bodyScale` are multipliers from 0.5 to 2; choose multipliers instead of passing pixel sizes. Map `radius` only when it is within the SQL token range of 0 to 48. Read and write deck tokens through `get-deck-design-tokens` and `update-deck-design-tokens` with the current `updatedAt`.",
+      "",
+      "---",
+      "",
+      theme.guide,
+    ].join("\n");
+    return { ...theme, guide: compatibilityNotes };
+  },
+});

package/corpus/templates/slides-2/actions/get-slides-2-upload-storage-status.ts

@@ -0,0 +1,17 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { isSlides2UploadStorageReady } from "../server/lib/upload-storage-status.js";
+
+export default defineAction({
+  description:
+    "Check whether reference-file storage is available to the signed-in Slides 2 workspace.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  readOnly: true,
+  requiresAuth: true,
+  agentTool: false,
+  run: async () => ({
+    referenceStorageReady: await isSlides2UploadStorageReady(),
+  }),
+});

package/corpus/templates/slides-2/actions/get-slides-notification-prefs.ts

@@ -0,0 +1,37 @@
+/**
+ * Read Slides email notification preferences for the current user.
+ *
+ * Usage:
+ *   pnpm action get-slides-notification-prefs
+ */
+
+import { defineAction, fail } from "@agent-native/core/action";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { getUserSetting } from "@agent-native/core/settings";
+import { z } from "zod";
+
+import {
+  getSlidesNotificationPreferences,
+  SLIDES_USER_PREFS_KEY,
+  type SlidesNotificationPreferences,
+} from "../shared/slides-user-prefs.js";
+
+export default defineAction({
+  description:
+    "Get whether the current user receives Slides emails when someone comments on or replies in their decks.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (): Promise<SlidesNotificationPreferences> => {
+    const email = getRequestUserEmail();
+    if (!email) {
+      fail("Sign in required", {
+        errorCode: "not_authenticated",
+        statusCode: 401,
+      });
+    }
+    return getSlidesNotificationPreferences(
+      await getUserSetting(email, SLIDES_USER_PREFS_KEY),
+    );
+  },
+});

package/corpus/templates/slides-2/actions/get-workspace-defaults.ts

@@ -0,0 +1,51 @@
+import { defineAction } from "@agent-native/core/action";
+import { loadAgentDesignSystemContext } from "@agent-native/core/shared";
+import { resolveAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import {
+  canManageWorkspaceDefaults,
+  getWorkspaceDefaults,
+} from "../server/workspace-defaults.js";
+import { isSlides2DeckData } from "../shared/deck-app-scope.js";
+import getDesignSystem from "./get-design-system.js";
+
+type DefaultRef =
+  | { id: string; title: string; unavailable?: false }
+  | { id: string; title: null; unavailable: true }
+  | null;
+
+export default defineAction({
+  description:
+    "Read the workspace-wide brand defaults: the default reference deck and design system new decks start from when the user has not picked their own. " +
+    "Call this before generating a deck from a bare prompt so the result is on brand.",
+  schema: z.object({}),
+  readOnly: true,
+  http: { method: "GET" },
+  mcpAnnotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: false,
+  },
+  run: async () => {
+    const defaults = await getWorkspaceDefaults();
+
+    let referenceDeck: DefaultRef = null;
+    if (defaults.referenceDeckId) {
+      const access = await resolveAccess("deck", defaults.referenceDeckId);
+      referenceDeck =
+        access && isSlides2DeckData(access.resource.data)
+          ? { id: defaults.referenceDeckId, title: access.resource.title }
+          : { id: defaults.referenceDeckId, title: null, unavailable: true };
+    }
+
+    return {
+      referenceDeck,
+      designSystem: await loadAgentDesignSystemContext(
+        defaults.designSystemId,
+        getDesignSystem,
+      ),
+      canManage: await canManageWorkspaceDefaults(),
+    };
+  },
+});

package/corpus/templates/slides-2/actions/image-gen-status.ts

@@ -0,0 +1,35 @@
+import { defineAction } from "@agent-native/core/action";
+import { resolveGeminiApiKey, resolveSecret } from "@agent-native/core/server";
+import { z } from "zod";
+
+export default defineAction({
+  description:
+    "Check which image generation providers are configured (agent CLI tool).",
+  schema: z.object({}),
+  readOnly: true,
+  http: false,
+  run: async () => {
+    const { getConfiguredProviders } =
+      await import("../server/handlers/image-providers/index.js");
+    const configured = await getConfiguredProviders();
+    const geminiStatus = (await resolveGeminiApiKey())
+      ? "Configured"
+      : "Not configured";
+    const openaiStatus = (await resolveSecret("OPENAI_API_KEY"))
+      ? "Configured"
+      : "Not configured";
+    const autoProvider =
+      configured.length > 0
+        ? `Auto mode will use: ${configured[0].name}`
+        : "No provider available";
+
+    return `Image Generation Status:
+========================
+Primary: Assets app (via A2A)
+Local fallback providers:
+Gemini: ${geminiStatus}
+OpenAI: ${openaiStatus}
+${autoProvider}
+Configured providers: ${configured.length > 0 ? configured.map((p) => p.name).join(", ") : "none"}`;
+  },
+});