@agent-native/core 0.103.1 → 0.105.0

package/corpus/templates/slides/actions/clone-context-slide.ts

@@ -0,0 +1,302 @@
+import { defineAction, embedApp } from "@agent-native/core";
+import { readAppState } from "@agent-native/core/application-state";
+import { buildDeepLink } from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+import {
+  nativeCreativeArtifactFromMetadata,
+  reassembleNativeCreativeArtifact,
+  validateCompiledNativeHtml,
+} from "@agent-native/creative-context";
+import {
+  getGenerationCreativeContext,
+  mergeCreativeContextReuseLabels,
+  recordGenerationCreativeContext,
+  replaceCreativeContextElementProvenance,
+} from "@agent-native/creative-context/server";
+import {
+  createContextPack,
+  deriveContextPack,
+  getCreativeContextItem,
+  getCreativeContextItemByExternalId,
+} from "@agent-native/creative-context/store";
+import type { ContextDetail } from "@agent-native/creative-context/types";
+import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+
+import { validateNativeSlideHtml } from "../app/lib/validate-native-slide-html.js";
+import { getDb, schema } from "../server/db/index.js";
+import { notifyClients } from "../server/handlers/decks.js";
+import { createDeckVersionSnapshot } from "../server/lib/deck-versions.js";
+import { getDeckUrl } from "./_app-url.js";
+import { withDeckLock } from "./patch-deck.js";
+
+export function cloneableNativeSlide(context: ContextDetail): {
+  content: string;
+  notes?: string;
+  sourceExternalId: string;
+} {
+  const artifact = nativeCreativeArtifactFromMetadata(context.version.metadata);
+  if (
+    !artifact ||
+    artifact.app !== "slides" ||
+    artifact.format !== "slides-html" ||
+    context.version.mimeType !== "text/html"
+  ) {
+    throw new Error("Creative Context item is not a Slides-native artifact.");
+  }
+  if (!context.version.content.includes("google-slides-native")) {
+    throw new Error(
+      "Slides-native artifact code is missing its compiler root.",
+    );
+  }
+  if (
+    context.item.provenance.compiler !==
+    "@agent-native/creative-context:google-slides-native"
+  ) {
+    throw new Error("Slides-native artifact compiler provenance is untrusted.");
+  }
+  validateCompiledNativeHtml(context.version.content, artifact);
+  const metadata = context.version.metadata;
+  const notes =
+    metadata &&
+    typeof metadata === "object" &&
+    !Array.isArray(metadata) &&
+    typeof (metadata as Record<string, unknown>).speakerNotes === "string"
+      ? ((metadata as Record<string, unknown>).speakerNotes as string)
+      : undefined;
+  return {
+    content: artifact.manifest
+      ? context.version.content
+      : validateNativeSlideHtml(context.version.content),
+    ...(notes ? { notes } : {}),
+    sourceExternalId: artifact.rootExternalId,
+  };
+}
+
+export default defineAction({
+  description:
+    "Clone one pinned Google Slides-native Creative Context item into an existing deck without regenerating or rewriting its editable HTML/CSS. Returns a link that opens the cloned slide in Slides.",
+  schema: z.object({
+    deckId: z.string().min(1).describe("Target Slides deck"),
+    itemId: z.string().min(1).describe("Creative Context item id"),
+    itemVersionId: z
+      .string()
+      .min(1)
+      .describe("Pinned immutable Creative Context version id"),
+    position: z.number().int().min(0).optional(),
+    slideId: z.string().min(1).optional(),
+  }),
+  mcpApp: {
+    compactCatalog: true,
+    resource: embedApp({
+      title: "Cloned native slide",
+      description: "Open the exact cloned artifact in the Slides editor.",
+      iframeTitle: "Agent-Native Slides",
+      openLabel: "Open cloned slide",
+      height: 680,
+    }),
+  },
+  http: false,
+  run: async ({ deckId, itemId, itemVersionId, position, slideId }) => {
+    const contextState = (await readAppState("creative-context").catch(
+      () => null,
+    )) as { contextMode?: "auto" | "off" } | null;
+    if (contextState?.contextMode === "off") {
+      throw new Error(
+        "Creative Context is off. Enable it before cloning a library slide.",
+      );
+    }
+    const context = await getCreativeContextItem(itemId, itemVersionId);
+    if (!context || context.version.id !== itemVersionId) {
+      throw new Error("Pinned Creative Context item version was not found.");
+    }
+    const source = cloneableNativeSlide(context);
+    const reassembled = await reassembleNativeCreativeArtifact({
+      root: context,
+      app: "slides",
+      format: "slides-html",
+      resolveChild: getCreativeContextItemByExternalId,
+    });
+    source.content = validateNativeSlideHtml(reassembled.html);
+    return withDeckLock(deckId, async () => {
+      await assertAccess("deck", deckId, "editor");
+      const db = getDb();
+      const [row] = await db
+        .select()
+        .from(schema.decks)
+        .where(eq(schema.decks.id, deckId));
+      if (!row) throw new Error(`Deck ${deckId} not found`);
+      const deck = JSON.parse(row.data) as Record<string, unknown>;
+      const slides = Array.isArray(deck.slides)
+        ? ([...deck.slides] as Array<Record<string, unknown>>)
+        : [];
+      const newSlideId = slideId ?? `slide-${nanoid(10)}`;
+      const reuseLabel = {
+        itemId,
+        itemVersionId,
+        kind: "google-slides-native-slide",
+        label: "Cloned native Google Slides artifact",
+        dataRole: "untrusted-reference" as const,
+        elementId: newSlideId,
+        influence: "reused" as const,
+      };
+      const clonedSlide = {
+        id: newSlideId,
+        content: source.content,
+        layout: "blank",
+        notes: source.notes ?? "",
+        creativeContextReuseLabels: [reuseLabel],
+        nativeArtifactSource: {
+          itemId,
+          itemVersionId,
+          externalId: source.sourceExternalId,
+        },
+      };
+      const insertAt =
+        position === undefined
+          ? slides.length
+          : Math.max(0, Math.min(position, slides.length));
+      slides.splice(insertAt, 0, clonedSlide);
+      const now = new Date().toISOString();
+      const existingContext =
+        deck.creativeContext &&
+        typeof deck.creativeContext === "object" &&
+        !Array.isArray(deck.creativeContext)
+          ? (deck.creativeContext as Record<string, unknown>)
+          : {};
+      const existingContextPackId =
+        typeof existingContext.contextPackId === "string"
+          ? existingContext.contextPackId
+          : null;
+      const existingLabels = Array.isArray(existingContext.reuseLabels)
+        ? existingContext.reuseLabels
+        : [];
+      if (existingContext.contextMode === "off") {
+        throw new Error(
+          "Creative Context is disabled for this deck. Enable it before cloning a library slide.",
+        );
+      }
+      const evidenceMembers = reassembled.evidence.map((entry) => ({
+        ...entry,
+        reason: "Exact native Google Slides reuse",
+      }));
+      const pack = existingContextPackId
+        ? await deriveContextPack({
+            packId: existingContextPackId,
+            name: `Clone: ${context.item.title}`.slice(0, 200),
+            addMembers: evidenceMembers,
+          })
+        : await createContextPack({
+            name: `Clone: ${context.item.title}`.slice(0, 200),
+            contextMode: "manual",
+            request: {
+              operation: "clone-native-artifact",
+              appId: "slides",
+              rootItemId: context.item.id,
+              rootItemVersionId: context.version.id,
+            },
+            members: evidenceMembers,
+          });
+      const contextMode = "pinned" as const;
+      const contextPackId = pack.id;
+      const evidenceLabels = reassembled.evidence.map((entry, index) => ({
+        ...entry,
+        kind: "google-slides-native-slide",
+        label:
+          entry.itemId === context.item.id
+            ? "Cloned native Google Slides artifact"
+            : `Native child ${index + 1}`,
+        dataRole: "untrusted-reference" as const,
+        elementId:
+          entry.itemId === context.item.id
+            ? newSlideId
+            : `${newSlideId}:evidence:${index + 1}`,
+        influence: "reused" as const,
+      }));
+      const reuseLabels = mergeCreativeContextReuseLabels(
+        existingLabels as (typeof reuseLabel)[],
+        evidenceLabels,
+      );
+      deck.slides = slides;
+      deck.updatedAt = now;
+      deck.creativeContext = { contextMode, contextPackId, reuseLabels };
+      const previousGeneration = await getGenerationCreativeContext({
+        appId: "slides",
+        artifactType: "deck",
+        artifactId: deckId,
+      });
+      const elementProvenance = replaceCreativeContextElementProvenance(
+        previousGeneration?.elementProvenance ?? [],
+        evidenceLabels.map((entry) => ({
+          elementId: entry.elementId,
+          itemId: entry.itemId,
+          itemVersionId: entry.itemVersionId,
+          influence: entry.influence,
+          label: entry.label,
+        })),
+      );
+
+      await createDeckVersionSnapshot(
+        {
+          id: row.id,
+          title: row.title,
+          data: row.data,
+          ownerEmail: row.ownerEmail,
+        },
+        { label: "Before cloning Creative Context slide" },
+      );
+      await db.transaction(async (tx: any) => {
+        await tx
+          .update(schema.decks)
+          .set({ data: JSON.stringify(deck), updatedAt: now })
+          .where(eq(schema.decks.id, deckId));
+        await recordGenerationCreativeContext(
+          {
+            appId: "slides",
+            artifactType: "deck",
+            artifactId: deckId,
+            contextMode,
+            contextPackId,
+            reuseLabels,
+            elementProvenance,
+          },
+          { db: tx },
+        );
+      });
+      notifyClients(deckId, { slideId: newSlideId, actor: "agent" });
+      return {
+        deckId,
+        slideId: newSlideId,
+        slideNumber: insertAt + 1,
+        slideCount: slides.length,
+        itemId,
+        itemVersionId,
+        contextPackId,
+        evidenceCount: reassembled.evidence.length,
+        clonedWithoutRegeneration: true,
+        deepLink: buildDeepLink({
+          app: "slides",
+          view: "editor",
+          params: { deckId, slideId: newSlideId },
+        }),
+        url: getDeckUrl(deckId),
+      };
+    });
+  },
+  link: ({ result }) => {
+    const value = result as { deckId?: string; deepLink?: string } | undefined;
+    if (!value?.deckId) return null;
+    return {
+      url:
+        value.deepLink ??
+        buildDeepLink({
+          app: "slides",
+          view: "editor",
+          params: { deckId: value.deckId },
+        }),
+      label: "Open cloned slide in Slides",
+      view: "editor",
+    };
+  },
+});

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

@@ -6,6 +6,11 @@ import {
   getRequestOrgId,
 } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
+import {
+  recordGenerationCreativeContext,
+  validateGenerationCreativeContext,
+} from "@agent-native/creative-context/server";
+import type { CreativeContextElementProvenance } from "@agent-native/creative-context/types";
 import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
@@ -16,6 +21,34 @@ import { createDeckVersionSnapshot } from "../server/lib/deck-versions.js";
 import { ASPECT_RATIO_VALUES } from "../shared/aspect-ratios.js";
 import { getDeckUrl } from "./_app-url.js";
 
+const ReuseLabelSchema = z
+  .object({
+    itemId: z.string().min(1).optional(),
+    itemVersionId: z.string().min(1).optional(),
+    kind: z.string().min(1),
+    label: z.string().min(1),
+    dataRole: z.literal("untrusted-reference").default("untrusted-reference"),
+    elementId: z.string().min(1).optional(),
+    influence: z
+      .enum(["reused", "adapted", "reference-conditioned", "generated"])
+      .optional(),
+  })
+  .superRefine((label, context) => {
+    const influence = label.influence ?? "reference-conditioned";
+    if (Boolean(label.itemId) !== Boolean(label.itemVersionId)) {
+      context.addIssue({
+        code: "custom",
+        message: "itemId and itemVersionId must be provided together",
+      });
+    }
+    if (influence !== "generated" && !label.itemId) {
+      context.addIssue({
+        code: "custom",
+        message: "Only generated labels may omit context item ids",
+      });
+    }
+  });
+
 const SlideSchema = z.object({
   id: z.string().describe("Unique slide ID, e.g. 'slide-1'"),
   content: z.string().describe("Full HTML content of the slide"),
@@ -33,6 +66,10 @@ const SlideSchema = z.object({
     .optional()
     .describe("Layout type hint"),
   notes: z.string().optional().describe("Speaker notes for this slide"),
+  creativeContextReuseLabels: z
+    .array(ReuseLabelSchema)
+    .optional()
+    .describe("Exact context item versions that influenced this slide"),
 });
 
 // Accept either a parsed array (HTTP/agent) or a JSON string (CLI)
@@ -77,6 +114,21 @@ export default defineAction({
       .string()
       .optional()
       .describe("Optional design system ID to link to the deck"),
+    contextPackId: z
+      .string()
+      .optional()
+      .describe("Immutable pack returned by pre-generation context search"),
+    contextModeOverride: z
+      .literal("off")
+      .optional()
+      .describe(
+        "Disable Creative Context for this deck generation only without changing the saved preference.",
+      ),
+    reuseLabels: z
+      .array(ReuseLabelSchema)
+      .optional()
+      .default([])
+      .describe("Deck-wide exact context item versions used"),
   }),
   mcpApp: {
     compactCatalog: true,
@@ -95,9 +147,69 @@ export default defineAction({
     deckId,
     aspectRatio,
     designSystemId,
+    contextPackId,
+    contextModeOverride,
+    reuseLabels,
   }) => {
     const db = getDb();
     const now = new Date().toISOString();
+    const validatedCreativeContext = await validateGenerationCreativeContext({
+      contextPackId,
+      contextModeOverride,
+      reuseLabels: Array.from(
+        new Map(
+          [
+            ...reuseLabels,
+            ...rawSlides.flatMap(
+              (slide) => slide.creativeContextReuseLabels ?? [],
+            ),
+          ].map((label) => [`${label.itemId}:${label.itemVersionId}`, label]),
+        ).values(),
+      ),
+    });
+    const creativeContextProvenance = {
+      contextMode: validatedCreativeContext.contextMode,
+      contextPackId: validatedCreativeContext.contextPackId,
+      reuseLabels: validatedCreativeContext.reuseLabels,
+    };
+    const elementProvenance: CreativeContextElementProvenance[] = [
+      ...reuseLabels.map((label) => ({
+        elementId: label.elementId ?? "deck",
+        influence: label.influence ?? ("reference-conditioned" as const),
+        ...(label.itemId ? { itemId: label.itemId } : {}),
+        ...(label.itemVersionId ? { itemVersionId: label.itemVersionId } : {}),
+        label: label.label,
+      })),
+      ...rawSlides.flatMap((slide) => {
+        const labels = slide.creativeContextReuseLabels ?? [];
+        return labels.length
+          ? labels.map((label) => ({
+              elementId: label.elementId ?? slide.id,
+              influence: label.influence ?? ("reference-conditioned" as const),
+              ...(label.itemId ? { itemId: label.itemId } : {}),
+              ...(label.itemVersionId
+                ? { itemVersionId: label.itemVersionId }
+                : {}),
+              label: label.label,
+            }))
+          : [
+              {
+                elementId: slide.id,
+                influence: "generated" as const,
+                label: "Net-new slide",
+              },
+            ];
+      }),
+      ...(reuseLabels.length === 0 && rawSlides.length === 0
+        ? [
+            {
+              elementId: "deck",
+              influence: "generated" as const,
+              label: "Net-new deck",
+            },
+          ]
+        : []),
+    ];
 
     const slides = rawSlides.map((s) => ({
       ...s,
@@ -134,6 +246,7 @@ export default defineAction({
         updatedAt: now,
         aspectRatio: aspectRatio ?? prevData.aspectRatio,
         designSystemId: designSystemId ?? prevData.designSystemId,
+        creativeContext: creativeContextProvenance,
       };
       await db
         .update(schema.decks)
@@ -148,6 +261,13 @@ export default defineAction({
       // refresh signal (cross-process polling fallback for serverless).
       notifyClients(deckId);
       await writeAppState("refresh-signal", { ts: now, source: "create-deck" });
+      await recordGenerationCreativeContext({
+        appId: "slides",
+        artifactType: "deck",
+        artifactId: deckId,
+        ...creativeContextProvenance,
+        ...(elementProvenance.length ? { elementProvenance } : {}),
+      });
       return {
         id: deckId,
         title,
@@ -155,6 +275,7 @@ export default defineAction({
         url: getDeckUrl(deckId),
         deepLink: deckDeepLink(deckId),
         slides,
+        ...creativeContextProvenance,
       };
     }
 
@@ -187,6 +308,7 @@ export default defineAction({
     };
     if (aspectRatio) data.aspectRatio = aspectRatio;
     if (resolvedDesignSystemId) data.designSystemId = resolvedDesignSystemId;
+    data.creativeContext = creativeContextProvenance;
     await db.insert(schema.decks).values({
       id,
       title,
@@ -200,6 +322,13 @@ export default defineAction({
 
     notifyClients(id);
     await writeAppState("refresh-signal", { ts: now, source: "create-deck" });
+    await recordGenerationCreativeContext({
+      appId: "slides",
+      artifactType: "deck",
+      artifactId: id,
+      ...creativeContextProvenance,
+      ...(elementProvenance.length ? { elementProvenance } : {}),
+    });
     return {
       id,
       title,
@@ -207,6 +336,7 @@ export default defineAction({
       url: getDeckUrl(id),
       deepLink: deckDeepLink(id),
       slides,
+      ...creativeContextProvenance,
     };
   },
   link: ({ result }) => {

package/corpus/templates/slides/actions/extract-pdf.ts

@@ -1,7 +1,6 @@
 import fs from "fs";
 
 import { parseArgs } from "@agent-native/core";
-import { PDFParse } from "pdf-parse";
 
 export default async function (args: string[]) {
   const { path: pdfPath } = parseArgs(args);
@@ -11,7 +10,12 @@ export default async function (args: string[]) {
   }
 
   const buf = fs.readFileSync(pdfPath);
-  const pdf = new PDFParse({ data: new Uint8Array(buf) });
+  const { CanvasFactory } = await import("pdf-parse/worker");
+  const { PDFParse } = await import("pdf-parse");
+  const pdf = new PDFParse({
+    data: new Uint8Array(buf),
+    CanvasFactory,
+  });
   const result = await pdf.getText();
   const pages = result.pages || [];
   console.log("Total pages:", pages.length);

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

@@ -211,13 +211,14 @@ export default defineAction({
     }
 
     if (detectedFormat === "pdf") {
+      const { CanvasFactory } = await import("pdf-parse/worker");
       const { PDFParse } = await import("pdf-parse");
       const { convertSectionsToSlides } =
         await import("../server/handlers/import/html-converter.js");
-      // pdf-parse v2 expects a LoadParameters object. Passing the byte array
-      // directly uses the old v1 shape and can fail while pdf.js initializes
-      // in production (the reported DOMMatrix error).
-      const pdf = new PDFParse({ data: new Uint8Array(fileBuffer) });
+      const pdf = new PDFParse({
+        data: new Uint8Array(fileBuffer),
+        CanvasFactory,
+      });
       const result = await pdf.getText();
       const pages = normalizePdfPages(result);
       const textPages = pages.filter((p) => p.text.trim());