@agent-native/core 0.92.5 → 0.92.7

package/corpus/templates/assets/actions/duplicate-library.ts

@@ -5,12 +5,14 @@ import {
   getRequestUserEmail,
 } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq, inArray, ne } from "drizzle-orm";
+import { and, eq, inArray, ne, notInArray } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { nowIso, parseJson, stringifyJson } from "../server/lib/json.js";
+import { normalizePresetReferences } from "../server/lib/preset-references.js";
+import { normalizePresetSkeletonSpec } from "../server/lib/preset-skeleton.js";
 import {
   serializeAsset,
   serializeGenerationPreset,
@@ -57,6 +59,35 @@ function remapJsonText(
   return stringifyJson(remapJsonValue(parseJson(text, {}), ids));
 }
 
+// Assets pinned by preset settings (reference board entries, skeleton plate/
+// mask/foreground) must be copied even when the general asset filter would
+// skip them — e.g. board subject photos upload as role "subject_reference".
+// Otherwise the duplicated preset keeps source-library asset ids and
+// generation in the copy fails its library-membership check.
+function pinnedPresetAssetIds(
+  presets: Array<{ settings: string | null }>,
+): Set<string> {
+  const ids = new Set<string>();
+  for (const preset of presets) {
+    const settings = parseJson<{
+      skeletonSpec?: unknown;
+      presetReferences?: unknown;
+    }>(preset.settings, {});
+    for (const entry of normalizePresetReferences(settings.presetReferences)) {
+      for (const assetId of entry.assetIds) ids.add(assetId);
+    }
+    const skeleton = normalizePresetSkeletonSpec(settings.skeletonSpec);
+    if (skeleton) {
+      ids.add(skeleton.background.assetId);
+      if (skeleton.mask) ids.add(skeleton.mask.assetId);
+      for (const layer of skeleton.foreground ?? []) {
+        if (typeof layer.source === "object") ids.add(layer.source.assetId);
+      }
+    }
+  }
+  return ids;
+}
+
 export default defineAction({
   description:
     "Duplicate a Brand Kit into a new private copy owned by the current user. Copies the kit metadata, collections, folders, generation presets, and curated reference/saved assets, but not generation history, handoff sessions, shares, or visibility.",
@@ -127,6 +158,23 @@ export default defineAction({
         ),
     ]);
 
+    const missingPinnedAssetIds = [...pinnedPresetAssetIds(presets)].filter(
+      (assetId) => !assets.some((asset) => asset.id === assetId),
+    );
+    if (missingPinnedAssetIds.length) {
+      const pinnedAssets = await db
+        .select()
+        .from(schema.assets)
+        .where(
+          and(
+            eq(schema.assets.libraryId, id),
+            inArray(schema.assets.id, missingPinnedAssetIds),
+            notInArray(schema.assets.status, ["archived", "failed"]),
+          ),
+        );
+      assets.push(...pinnedAssets);
+    }
+
     const collectionIds = new Map(
       collections.map((collection) => [collection.id, nanoid()]),
     );

package/corpus/templates/assets/actions/generate-image-batch.ts

@@ -23,9 +23,14 @@ import { upsertVariantSlot } from "./variant-slots.js";
 
 const IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12 * 60_000;
 
+const presetReferenceFillSchema = z.object({
+  referenceId: z.string().min(1),
+  assetIds: z.array(z.string().min(1)).min(1).max(4),
+});
+
 export default defineAction({
   description:
-    "Generate several brand-consistent images in parallel from one brand kit/library. Use @brand-kit mentions as libraryId and @preset mentions as presetId when present. This is synchronous for images: one call waits for every slot and returns final image artifacts. Use this for slide decks, landing pages, and multi-slot design work. Do not call get-generation-run or refresh-generation-run after a normal image batch result.",
+    "Generate several brand-consistent images in parallel from one brand kit/library. Use @brand-kit mentions as libraryId and @preset mentions as presetId when present. If no preset is tagged, call list-generation-presets first and use a matching preset's presetId; the user may not know presets exist. Generate presetless only when no preset matches the request. This is synchronous for images: one call waits for every slot and returns final image artifacts. Use this for slide decks, landing pages, and multi-slot design work. Do not call get-generation-run or refresh-generation-run after a normal image batch result.",
   schema: z.object({
     libraryId: z
       .string()
@@ -40,6 +45,13 @@ export default defineAction({
       .describe(
         "Generation preset ID (from a @preset mention or list-generation-presets). The preset already defines aspectRatio, imageSize, model, tier, and category. When you set presetId, OMIT each slot's aspectRatio/imageSize and the top-level model/tier so the preset's values are used; only pass one when the user explicitly asks for a value that differs from the preset.",
       ),
+    presetReferenceFills: z
+      .array(presetReferenceFillSchema)
+      .max(6)
+      .optional()
+      .describe(
+        'Per-run images for the preset\'s reference board (see the tagged preset brief or list-generation-presets settings.presetReferences). Each fill REPLACES the images of one variable entry by id, e.g. [{ referenceId: "guest-speaker", assetIds: ["..."] }]. Required entries without pinned images MUST be filled or the call fails. Only valid when presetId is set. Applies to every slot in the batch.',
+      ),
     sessionId: z.string().optional(),
     slots: z
       .array(
@@ -150,6 +162,7 @@ export default defineAction({
               libraryId: base.libraryId,
               collectionId: base.collectionId,
               presetId: base.presetId,
+              presetReferenceFills: base.presetReferenceFills,
               sessionId: base.sessionId,
               prompt: slot.prompt,
               embeddedText: slot.embeddedText,

package/corpus/templates/assets/actions/generate-image.ts

@@ -9,7 +9,7 @@ import {
   getRequestOrgId,
 } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { eq, inArray } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
@@ -21,6 +21,7 @@ import {
   DEFAULT_GENERATION_REFERENCE_LIMIT,
   generateWithManagedImageProvider,
   isImageGenerationSetupError,
+  loadReferenceData,
   resolveImageModelForRequest,
   selectReferences,
   type ReferenceForGeneration,
@@ -33,6 +34,11 @@ import {
   prepareGptImage2SkeletonInpaintImages,
 } from "../server/lib/image-processing.js";
 import { nowIso, parseJson, stringifyJson } from "../server/lib/json.js";
+import {
+  normalizePresetReferences,
+  PRESET_REFERENCE_ROLE_MAP,
+  resolvePresetReferenceFills,
+} from "../server/lib/preset-references.js";
 import {
   aspectRatioValue,
   clampCutoutAspectRatio,
@@ -65,9 +71,14 @@ import { upsertVariantSlot, wasVariantSlotDismissed } from "./variant-slots.js";
 
 const IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12 * 60_000;
 
+const presetReferenceFillSchema = z.object({
+  referenceId: z.string().min(1),
+  assetIds: z.array(z.string().min(1)).min(1).max(4),
+});
+
 export default defineAction({
   description:
-    "Generate one brand-consistent image from a brand kit/library. This is synchronous for images and returns the final asset with preview/download/embed URLs. Use @brand-kit mentions as libraryId and @preset mentions as presetId when present. Use generate-image-batch for multiple independent slots; do not poll image runs after this action returns.",
+    "Generate one brand-consistent image from a brand kit/library. This is synchronous for images and returns the final asset with preview/download/embed URLs. Use @brand-kit mentions as libraryId and @preset mentions as presetId when present. If no preset is tagged, call list-generation-presets first and use a matching preset's presetId; the user may not know presets exist. Generate presetless only when no preset matches the request. Use generate-image-batch for multiple independent slots; do not poll image runs after this action returns.",
   schema: z.object({
     libraryId: z
       .string()
@@ -124,6 +135,13 @@ export default defineAction({
       .describe(
         "Exact reference assets to use. When omitted, the server deterministically chooses a small relevant subset from the latest library references.",
       ),
+    presetReferenceFills: z
+      .array(presetReferenceFillSchema)
+      .max(6)
+      .optional()
+      .describe(
+        'Per-run images for the preset\'s reference board (see the tagged preset brief or list-generation-presets settings.presetReferences). Each fill REPLACES the images of one variable entry by id, e.g. [{ referenceId: "guest-speaker", assetIds: ["..."] }]. Required entries without pinned images MUST be filled or the call fails. Only valid when presetId is set.',
+      ),
     includeLogo: z.coerce
       .boolean()
       .optional()
@@ -281,10 +299,27 @@ export default defineAction({
       tier?: ImageQualityTier;
       includeLogo?: boolean;
       skeletonSpec?: unknown;
+      presetReferences?: unknown;
     }>(preset?.settings, {});
     const skeletonSpec = normalizePresetSkeletonSpec(
       presetSettings.skeletonSpec,
     );
+    const presetReferences = normalizePresetReferences(
+      presetSettings.presetReferences,
+    );
+    if (args.presetReferenceFills?.length && !preset) {
+      throw new Error(
+        "presetReferenceFills requires a presetId whose preset declares a reference board.",
+      );
+    }
+    const resolvedPresetReferences = resolvePresetReferenceFills({
+      entries: presetReferences,
+      fills: args.presetReferenceFills,
+      presetTitle: preset?.title ?? "",
+    });
+    const boardAssignments = Object.fromEntries(
+      resolvedPresetReferences.map((item) => [item.entry.id, item.assetIds]),
+    );
     const isSkeletonCutout = skeletonSpec?.contentMode === "cutout";
     const outputAspectRatio = (args.aspectRatio ??
       preset?.aspectRatio ??
@@ -333,11 +368,32 @@ export default defineAction({
         model: resolvedModel,
       });
     }
+    // Mirror the create/update-generation-preset guard for per-run model
+    // overrides: subject board photos on a model without character
+    // consistency would silently ignore the people they exist to preserve.
+    if (
+      resolvedModel === "gemini-2.5-flash-image" &&
+      resolvedPresetReferences.some((item) => item.entry.role === "subject")
+    ) {
+      throw new Error(
+        "Subject reference entries need a model with character consistency. Use gemini-3.1-flash-image, gemini-3-pro-image, gpt-image-1, or gpt-image-2.",
+      );
+    }
     const resolvedCategories =
       args.categories ??
       (preset?.category ? ([preset.category] as any) : undefined);
     const skeletonReferenceExclusionIds =
       skeletonCompositeAssetIds(skeletonSpec);
+    const boardRefs = await loadPresetReferenceBoardRefs({
+      db,
+      libraryId: args.libraryId,
+      resolved: resolvedPresetReferences,
+    });
+    const boardAssetIdSet = new Set(boardRefs.map((ref) => ref.id));
+    const referenceExclusionIds = [
+      ...(skeletonReferenceExclusionIds ?? []),
+      ...boardAssetIdSet,
+    ];
     const skeletonAssets = skeletonSpec
       ? await loadSkeletonAssets({
           spec: skeletonSpec,
@@ -395,35 +451,67 @@ export default defineAction({
           .join("\n")
       : "";
     let references: ReferenceForGeneration[];
+    const baseReferenceLimit =
+      args.intent !== "restyle" &&
+      preset?.referencePolicy === "explicit" &&
+      !args.referenceAssetIds?.length
+        ? 0
+        : DEFAULT_GENERATION_REFERENCE_LIMIT;
     if (useSkeletonInpaint) {
-      references = skeletonInpaint?.references ?? [];
+      const guidanceReferenceLimit = Math.max(
+        0,
+        baseReferenceLimit - boardRefs.length,
+      );
+      const guidanceReferences =
+        baseReferenceLimit > 0 || args.referenceAssetIds?.length
+          ? await selectReferences({
+              libraryId: args.libraryId,
+              collectionId: resolvedCollectionId,
+              categories: resolvedCategories,
+              referenceAssetIds: args.referenceAssetIds,
+              excludeAssetIds: referenceExclusionIds,
+              sourceAssetId: args.sourceAssetId,
+              subjectAssetId: args.subjectAssetId,
+              intent: args.intent,
+              limit: guidanceReferenceLimit,
+            })
+          : [];
+      const inpaintReferences = skeletonInpaint?.references ?? [];
+      const [plateReference, ...maskReferences] = inpaintReferences;
+      references = [
+        ...(plateReference ? [plateReference] : []),
+        ...boardRefs.map(referenceForSkeletonInpaintGuidance),
+        ...guidanceReferences.map(referenceForSkeletonInpaintGuidance),
+        ...maskReferences,
+      ];
     } else {
       const backgroundPlateReference =
         backgroundPlateReferenceForSkeleton(skeletonAssets);
-      const baseReferenceLimit =
-        args.intent !== "restyle" &&
-        preset?.referencePolicy === "explicit" &&
-        !args.referenceAssetIds?.length
-          ? 0
-          : DEFAULT_GENERATION_REFERENCE_LIMIT;
-      const referenceLimit =
-        backgroundPlateReference && baseReferenceLimit > 0
+      const referenceLimit = Math.max(
+        0,
+        (backgroundPlateReference && baseReferenceLimit > 0
           ? baseReferenceLimit + 1
-          : baseReferenceLimit;
-      references = await selectReferences({
-        libraryId: args.libraryId,
-        collectionId: resolvedCollectionId,
-        categories: resolvedCategories,
-        referenceAssetIds: args.referenceAssetIds,
-        excludeAssetIds: skeletonReferenceExclusionIds,
-        sourceAssetId: args.sourceAssetId,
-        subjectAssetId: args.subjectAssetId,
-        intent: args.intent,
-        limit: referenceLimit,
-      });
-      if (backgroundPlateReference) {
-        references.unshift(backgroundPlateReference);
-      }
+          : baseReferenceLimit) - boardRefs.length,
+      );
+      const autoReferences =
+        referenceLimit > 0 || args.referenceAssetIds?.length
+          ? await selectReferences({
+              libraryId: args.libraryId,
+              collectionId: resolvedCollectionId,
+              categories: resolvedCategories,
+              referenceAssetIds: args.referenceAssetIds,
+              excludeAssetIds: referenceExclusionIds,
+              sourceAssetId: args.sourceAssetId,
+              subjectAssetId: args.subjectAssetId,
+              intent: args.intent,
+              limit: referenceLimit,
+            })
+          : [];
+      references = [
+        ...(backgroundPlateReference ? [backgroundPlateReference] : []),
+        ...boardRefs,
+        ...autoReferences,
+      ];
     }
     const compiledPrompt = compilePrompt({
       libraryTitle: library.title,
@@ -448,6 +536,12 @@ export default defineAction({
       category,
       intent: args.intent,
       styleStrength: args.styleStrength,
+      referenceBoard: resolvedPresetReferences.map((item) => ({
+        label: item.entry.label,
+        role: item.entry.role,
+        count: item.assetIds.length,
+        description: item.entry.description,
+      })),
     });
     const runId = nanoid();
     const now = nowIso();
@@ -476,6 +570,7 @@ export default defineAction({
       selectionReasons: Object.fromEntries(
         references.map((ref) => [ref.id, ref.selectionReason ?? "scored"]),
       ),
+      boardAssignments,
     };
     const settingsUsed = {
       model: resolvedModel,
@@ -497,6 +592,7 @@ export default defineAction({
       embeddedText: args.embeddedText ?? null,
       textPlacement: args.textPlacement ?? null,
       customInstructions: library.customInstructions ?? "",
+      boardAssignments,
     };
     const dismissibleSlot = args.dismissible !== false && Boolean(slotId);
     const baseMetadata = {
@@ -593,6 +689,7 @@ export default defineAction({
             collectionId: resolvedCollectionId ?? null,
             source: args.source,
             callerAppId: args.callerAppId,
+            hasBoardReferences: boardRefs.length > 0,
           }),
       );
       await deleteAppState("image-generation-setup").catch(() => {});
@@ -847,6 +944,62 @@ function backgroundPlateReferenceForSkeleton(
   };
 }
 
+async function loadPresetReferenceBoardRefs(input: {
+  db: any;
+  libraryId: string;
+  resolved: Array<{
+    entry: {
+      id: string;
+      role: keyof typeof PRESET_REFERENCE_ROLE_MAP;
+    };
+    assetIds: string[];
+  }>;
+}): Promise<ReferenceForGeneration[]> {
+  const assetIds = [
+    ...new Set(input.resolved.flatMap((item) => item.assetIds)),
+  ];
+  if (!assetIds.length) return [];
+
+  const rows = await input.db
+    .select()
+    .from(schema.assets)
+    .where(inArray(schema.assets.id, assetIds));
+  const byId = new Map<string, any>(
+    (rows as any[]).map((asset) => [asset.id, asset]),
+  );
+  const valid = assetIds.every((assetId) => {
+    const asset = byId.get(assetId);
+    return (
+      asset &&
+      asset.libraryId === input.libraryId &&
+      typeof asset.mimeType === "string" &&
+      asset.mimeType.startsWith("image/") &&
+      asset.status !== "archived" &&
+      asset.status !== "failed"
+    );
+  });
+  if (!valid) {
+    throw new Error(
+      "Reference board images must be images in this asset library.",
+    );
+  }
+
+  const refs: ReferenceForGeneration[] = [];
+  for (const item of input.resolved) {
+    const assets = item.assetIds
+      .map((assetId) => byId.get(assetId))
+      .filter((asset): asset is any => asset != null);
+    refs.push(
+      ...(await loadReferenceData(
+        assets,
+        () => PRESET_REFERENCE_ROLE_MAP[item.entry.role],
+        () => `preset-ref:${item.entry.id}`,
+      )),
+    );
+  }
+  return refs;
+}
+
 async function inpaintReferencesForSkeleton(
   skeletonAssets: LoadedSkeletonAssets | null,
 ): Promise<{
@@ -897,6 +1050,22 @@ async function inpaintReferencesForSkeleton(
   };
 }
 
+function referenceForSkeletonInpaintGuidance(
+  ref: ReferenceForGeneration,
+): ReferenceForGeneration {
+  if (
+    ref.role !== "subject_reference" &&
+    ref.role !== "generated" &&
+    ref.role !== "edit_target"
+  ) {
+    return ref;
+  }
+  return {
+    ...ref,
+    role: "product_reference",
+  };
+}
+
 function closestSupportedAspectRatioForSize(
   size: { width: number; height: number },
   supported: readonly AspectRatio[],