@agent-native/core 0.78.0 → 0.78.2

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

@@ -32,9 +32,14 @@ import { serializeAsset, serializeGenerationRun } from "./_helpers.js";
 
 export default defineAction({
   description:
-    "Start an async Veo video generation run from an asset library. Poll the returned run with refresh-generation-run until it completes and creates a video asset.",
+    "Start an async Veo video generation run from a brand kit/library. Use a media-type @mention with refId video to choose this instead of image generation, and use a brand-kit @mention as libraryId. Poll the returned run with refresh-generation-run until it completes and creates a video asset.",
   schema: z.object({
-    libraryId: z.string(),
+    libraryId: z
+      .string()
+      .optional()
+      .describe(
+        "Brand kit/library ID. Pass the refId from a brand-kit @mention, or choose a kit from view-screen/list-libraries.",
+      ),
     folderId: z.string().min(1).nullable().optional(),
     collectionId: z.string().optional(),
     prompt: z.string().min(1),
@@ -66,7 +71,17 @@ export default defineAction({
     callerAppId: z.string().optional(),
     waitForCompletion: z.coerce.boolean().default(false),
   }),
-  run: async (args) => {
+  run: async (input) => {
+    const libraryId = input.libraryId;
+    if (!libraryId) {
+      throw new Error(
+        "No brand kit selected. Tag a brand kit with @ or pass libraryId.",
+      );
+    }
+    const args = {
+      ...input,
+      libraryId,
+    };
     await assertAccess("asset-library", args.libraryId, "editor");
     const db = getDb();
     const [library] = await db

package/corpus/templates/assets/actions/list-assets.ts

@@ -1,5 +1,6 @@
 import { defineAction } from "@agent-native/core";
-import { and, desc, eq, isNull } from "drizzle-orm";
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, desc, eq, inArray, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -17,9 +18,9 @@ import {
 
 export default defineAction({
   description:
-    "List DAM assets in a library, optionally filtered by folder, collection, media type, status, role, category, or text query.",
+    "List DAM assets in one library, or across all accessible libraries when libraryId is omitted. Optionally filter by folder, collection, media type, status, role, category, or text query.",
   schema: z.object({
-    libraryId: z.string(),
+    libraryId: z.string().optional(),
     collectionId: z.string().optional(),
     folderId: z.string().nullable().optional(),
     mediaType: z.enum(ASSET_MEDIA_TYPES).optional(),
@@ -51,8 +52,32 @@ export default defineAction({
     includeCandidates,
     candidateRunIds,
   }) => {
-    await requireLibrary(libraryId);
-    const filters = [eq(schema.assets.libraryId, libraryId)];
+    const db = getDb();
+    const libraryRows = libraryId
+      ? [await requireLibrary(libraryId)]
+      : await db
+          .select({
+            id: schema.assetLibraries.id,
+            title: schema.assetLibraries.title,
+          })
+          .from(schema.assetLibraries)
+          .where(
+            and(
+              accessFilter(schema.assetLibraries, schema.assetLibraryShares),
+              isNull(schema.assetLibraries.archivedAt),
+            ),
+          );
+    const libraryIds = libraryRows.map((library) => library.id);
+    if (!libraryIds.length) return { count: 0, assets: [] };
+
+    const libraryTitleById = new Map(
+      libraryRows.map((library) => [library.id, library.title]),
+    );
+    const filters = [
+      libraryId
+        ? eq(schema.assets.libraryId, libraryId)
+        : inArray(schema.assets.libraryId, libraryIds),
+    ];
     if (collectionId)
       filters.push(eq(schema.assets.collectionId, collectionId));
     if (folderId !== undefined) {
@@ -67,7 +92,6 @@ export default defineAction({
     if (role) filters.push(eq(schema.assets.role, role));
     const normalizedQuery = query?.trim().toLowerCase();
     const candidateRunIdSet = new Set(candidateRunIds ?? []);
-    const db = getDb();
     const [rows, lineageRows] = await Promise.all([
       db
         .select()
@@ -89,7 +113,11 @@ export default defineAction({
           createdAt: schema.assets.createdAt,
         })
         .from(schema.assets)
-        .where(eq(schema.assets.libraryId, libraryId)),
+        .where(
+          libraryId
+            ? eq(schema.assets.libraryId, libraryId)
+            : inArray(schema.assets.libraryId, libraryIds),
+        ),
     ]);
     const lineageById = buildAssetLineage(lineageRows);
     const assets = rows
@@ -111,7 +139,10 @@ export default defineAction({
         );
       })
       .filter((asset) => assetMatchesSearch(asset, normalizedQuery, category))
-      .map((asset) => serializeAsset(asset, lineageById.get(asset.id) ?? null));
+      .map((asset) => ({
+        ...serializeAsset(asset, lineageById.get(asset.id) ?? null),
+        libraryTitle: libraryTitleById.get(asset.libraryId) ?? null,
+      }));
     return { count: assets.length, assets };
   },
 });

package/corpus/templates/assets/actions/list-libraries.ts

@@ -67,10 +67,11 @@ export default defineAction({
     "List asset libraries accessible to the current user, including counts and preview thumbnails.",
   schema: z.object({
     compact: z.coerce.boolean().optional(),
+    includeFolders: z.coerce.boolean().optional(),
   }),
   http: { method: "GET" },
   readOnly: true,
-  run: async ({ compact }) => {
+  run: async ({ compact, includeFolders }) => {
     const db = getDb();
     const rows = await db
       .select()
@@ -93,8 +94,23 @@ export default defineAction({
             ),
           )
       : [];
+    const folders =
+      includeFolders && rows.length
+        ? await db
+            .select()
+            .from(schema.assetFolders)
+            .where(
+              inArray(
+                schema.assetFolders.libraryId,
+                rows.map((row) => row.id),
+              ),
+            )
+        : [];
     const libraries = rows.map((row) => {
       const libAssets = assets.filter((asset) => asset.libraryId === row.id);
+      const libFolders = includeFolders
+        ? folders.filter((folder) => folder.libraryId === row.id)
+        : undefined;
       const visibleAssets = libAssets.filter((asset) =>
         shouldIncludeAssetInLibraryResults(asset),
       );
@@ -106,7 +122,12 @@ export default defineAction({
       const previewAssets = uniqueAssets([cover, ...imageAssets]).slice(0, 4);
       const base = serializeLibrary(row);
       return compact
-        ? { id: base.id, title: base.title, description: base.description }
+        ? {
+            id: base.id,
+            title: base.title,
+            description: base.description,
+            ...(includeFolders ? { folders: libFolders } : {}),
+          }
         : {
             ...base,
             referenceCount: visibleAssets.filter((asset) =>
@@ -122,6 +143,7 @@ export default defineAction({
             ).length,
             coverAsset: cover ? serializeAsset(cover) : null,
             previewAssets: previewAssets.map(serializeAsset),
+            ...(includeFolders ? { folders: libFolders } : {}),
           };
     });
     return { count: libraries.length, libraries };

package/corpus/templates/assets/actions/navigate.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 
 export default defineAction({
   description:
-    "Navigate the Assets UI. Views (internal keys, with the surface they open): create, picker (the image Library browser), libraries (the Brand Kits list), library (a single Brand Kit), asset, generation-session, generation-run, extensions, audit, settings. Use threadId to open a specific create/chat thread; use libraryId, assetId, sessionId, runId, or extensionId where appropriate.",
+    "Navigate the Assets UI. Views (internal keys, with the surface they open): create, picker (the embedded image Library picker), libraries (the unified Library workspace), library (a single Brand Kit inside Library), asset, generation-session, generation-run, extensions, audit, settings. Use threadId to open a specific create/chat thread; use libraryId, assetId, sessionId, runId, or extensionId where appropriate.",
   schema: z.object({
     view: z
       .enum([

package/corpus/templates/assets/actions/open-asset-picker.ts

@@ -1,4 +1,7 @@
 import { defineAction, embedApp } from "@agent-native/core";
+import type { ActionRunContext } from "@agent-native/core/action";
+import { writeAppState } from "@agent-native/core/application-state";
+import { getRequestRunContext } from "@agent-native/core/server/request-context";
 import { z } from "zod";
 
 import { IMAGE_QUALITY_TIERS, STYLE_STRENGTHS } from "../shared/api.js";
@@ -77,6 +80,7 @@ const schema = z.object({
 });
 
 type OpenAssetPickerArgs = z.infer<typeof schema>;
+const SAFE_BROWSER_TAB_ID_RE = /^[A-Za-z0-9_-]{1,96}$/;
 
 type ActionWithToolParameters = {
   tool: { parameters?: { properties?: Record<string, any> } };
@@ -109,6 +113,7 @@ const FALLBACK_INSTRUCTIONS =
 
 function pickerPath(args: Partial<OpenAssetPickerArgs>): string {
   const params = new URLSearchParams();
+  params.set("__an_picker", "1");
   params.set("mediaType", args.mediaType ?? "image");
   if (args.prompt?.trim()) params.set("prompt", args.prompt.trim());
   if (args.query?.trim()) params.set("q", args.query.trim());
@@ -134,6 +139,21 @@ function pickerPath(args: Partial<OpenAssetPickerArgs>): string {
   return `/library?${params.toString()}`;
 }
 
+function navigateCommandKey(): string | null {
+  const browserTabId = getRequestRunContext()?.browserTabId?.trim();
+  if (browserTabId && SAFE_BROWSER_TAB_ID_RE.test(browserTabId)) {
+    return `navigate:${browserTabId}`;
+  }
+  return null;
+}
+
+function shouldWriteNavigateCommand(
+  context: ActionRunContext | undefined,
+  commandKey: string | null,
+): commandKey is string {
+  return Boolean(commandKey) && context?.caller !== "mcp";
+}
+
 const action = defineAction({
   description:
     'Open the image Library picker inline so a person can browse, search, generate, and select an image or video asset. When the user asks to create a specific image and choose the best one, pass prompt, autoGenerate: true, and count: 3 so the Library opens with generated candidates. If the host can only open a browser link (e.g. a CLI or code editor), surface that link: after the user picks, the page auto-copies a short paste-back summary — or the user can simply tell you which candidate they want (e.g. "use image A"). Use search-assets, generate-image, generate-video, and export-asset for unattended flows.',
@@ -173,8 +193,25 @@ const action = defineAction({
       view: "picker",
     };
   },
-  run: async (args) => {
+  run: async (args, context) => {
     const path = pickerPath(args);
+    const commandKey = navigateCommandKey();
+    if (shouldWriteNavigateCommand(context, commandKey)) {
+      const command = {
+        view: "picker" as const,
+        mediaType: args.mediaType,
+        path,
+        libraryId: args.libraryId ?? null,
+        query: args.query ?? null,
+        prompt: args.prompt ?? null,
+        aspectRatio: args.aspectRatio ?? null,
+        presetId: args.presetId ?? null,
+        _writeId: `open-asset-picker-${Date.now()}-${Math.random()
+          .toString(36)
+          .slice(2, 8)}`,
+      };
+      await writeAppState(commandKey, command);
+    }
     return {
       app: "assets",
       view: "picker",

package/corpus/templates/assets/actions/refresh-generation-run.ts

@@ -36,6 +36,14 @@ async function syncImageVariantSlot(
     typeof metadata.variantBatchId === "string" && metadata.variantBatchId
       ? metadata.variantBatchId
       : null;
+  const threadId =
+    typeof metadata.threadId === "string" && metadata.threadId
+      ? metadata.threadId
+      : null;
+  const variantScopeId =
+    typeof metadata.variantScopeId === "string" && metadata.variantScopeId
+      ? metadata.variantScopeId
+      : null;
   const serialized = options.asset ? serializeAsset(options.asset) : null;
 
   await upsertVariantSlot({
@@ -45,6 +53,8 @@ async function syncImageVariantSlot(
     collectionId: run.collectionId ?? null,
     presetId: run.presetId ?? null,
     sessionId: run.sessionId ?? null,
+    threadId,
+    variantScopeId,
     prompt: run.prompt,
     slotId,
     status,

package/corpus/templates/assets/actions/save-generated-image.ts

@@ -1,4 +1,5 @@
 import { defineAction } from "@agent-native/core";
+import type { ActionRunContext } from "@agent-native/core/action";
 import {
   deleteAppState,
   readAppState,
@@ -7,28 +8,29 @@ import {
 import { z } from "zod";
 
 import { markAssetSaved } from "../server/handlers/assets.js";
-import type { AssetVariantState } from "../shared/api.js";
 import { getAssetOrThrow, serializeAsset } from "./_helpers.js";
+import {
+  deleteVariantState,
+  readVariantState,
+  writeVariantState,
+} from "./variant-slots.js";
 
 export default defineAction({
   description:
-    "Save a generated asset candidate to the library. Accepts an assetId directly or a variant slot ID from application_state.asset-variants.",
+    "Save a generated asset candidate to the library. Accepts an assetId directly or a variant slot ID from the current thread's application_state.asset-variants.",
   schema: z.object({
     assetId: z.string().optional(),
     slotId: z.string().optional(),
     folderId: z.string().min(1).nullable().optional(),
+    threadId: z.string().nullable().optional(),
   }),
-  run: async ({ assetId, slotId, folderId }) => {
+  run: async (
+    { assetId, slotId, folderId, threadId },
+    context?: ActionRunContext,
+  ) => {
+    const effectiveThreadId = threadId ?? context?.threadId ?? null;
     let resolvedAssetId = assetId;
-    const raw = (await readAppState("asset-variants")) as unknown | null;
-    const legacyRaw =
-      raw ??
-      ((await readAppState("image-variants").catch(() => null)) as
-        | unknown
-        | null);
-    const variants = (raw ?? null) as AssetVariantState | null;
-    const legacyVariants = (legacyRaw ?? null) as AssetVariantState | null;
-    const activeVariants = variants ?? legacyVariants;
+    const activeVariants = await readVariantState(effectiveThreadId);
     if (!resolvedAssetId && slotId && activeVariants) {
       resolvedAssetId = activeVariants.slots.find(
         (slot) => slot.slotId === slotId,
@@ -39,18 +41,18 @@ export default defineAction({
     await markAssetSaved(resolvedAssetId, folderId);
     const asset = await getAssetOrThrow(resolvedAssetId);
     if (activeVariants) {
+      const stateThreadId =
+        effectiveThreadId ??
+        activeVariants.variantScopeId ??
+        activeVariants.threadId ??
+        null;
       activeVariants.slots = activeVariants.slots.filter(
         (slot) => slot.assetId !== resolvedAssetId,
       );
       if (activeVariants.slots.length) {
-        await writeAppState(
-          "asset-variants",
-          activeVariants as unknown as Record<string, unknown>,
-        );
-        await deleteAppState("image-variants").catch(() => {});
+        await writeVariantState(activeVariants, stateThreadId);
       } else {
-        await deleteAppState("asset-variants");
-        await deleteAppState("image-variants").catch(() => {});
+        await deleteVariantState(stateThreadId);
       }
     }
     return serializeAsset({ ...asset, status: "saved" });

package/corpus/templates/assets/actions/variant-slots.ts

@@ -7,13 +7,21 @@ import {
 import { nowIso } from "../server/lib/json.js";
 import type { AssetVariantState } from "../shared/api.js";
 
-type VariantSlotInput = {
+const GLOBAL_VARIANT_STATE_KEY = "asset-variants";
+const LEGACY_VARIANT_STATE_KEY = "image-variants";
+
+type VariantScopeInput = {
   runId: string;
   batchId?: string | null;
   libraryId: string;
   collectionId?: string | null;
   presetId?: string | null;
   sessionId?: string | null;
+  threadId?: string | null;
+  variantScopeId?: string | null;
+};
+
+type VariantSlotInput = VariantScopeInput & {
   prompt: string;
   slotId: string;
   status: "pending" | "ready" | "failed";
@@ -25,6 +33,29 @@ type VariantSlotInput = {
 
 let variantStateLock: Promise<void> = Promise.resolve();
 
+export function variantStateKey(scopeId?: string | null) {
+  const scopedId = normalizeVariantScopeId(scopeId);
+  return scopedId
+    ? `${GLOBAL_VARIANT_STATE_KEY}:${scopedId}`
+    : GLOBAL_VARIANT_STATE_KEY;
+}
+
+function normalizeVariantScopeId(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return /^[A-Za-z0-9:_-]{1,160}$/.test(trimmed) ? trimmed : null;
+}
+
+function variantScopeIdFor(input: {
+  threadId?: string | null;
+  variantScopeId?: string | null;
+}): string | null {
+  return (
+    normalizeVariantScopeId(input.variantScopeId) ??
+    normalizeVariantScopeId(input.threadId)
+  );
+}
+
 export async function withVariantStateLock<T>(
   operation: () => Promise<T>,
 ): Promise<T> {
@@ -44,9 +75,17 @@ export async function withVariantStateLock<T>(
 export async function wasVariantSlotDismissed(
   libraryId: string,
   slotId: string,
+  scope?:
+    | { threadId?: string | null; variantScopeId?: string | null }
+    | string
+    | null,
 ): Promise<boolean> {
   return withVariantStateLock(async () => {
-    const state = await readVariantStateUnlocked();
+    const scopeId =
+      typeof scope === "object" && scope
+        ? variantScopeIdFor(scope)
+        : normalizeVariantScopeId(scope);
+    const state = await readVariantStateUnlocked(scopeId);
     if (!state) return true;
     if (state.libraryId !== libraryId) return false;
     return !state.slots.some((slot) => slot.slotId === slotId);
@@ -55,26 +94,32 @@ export async function wasVariantSlotDismissed(
 
 export async function upsertVariantSlot(input: VariantSlotInput) {
   await withVariantStateLock(async () => {
-    const previous = await readVariantStateUnlocked();
-    const state = isSameVariantScope(previous, input)
-      ? previous
-      : {
-          runId: input.runId,
-          batchId: input.batchId ?? null,
-          libraryId: input.libraryId,
-          collectionId: input.collectionId,
-          presetId: input.presetId ?? null,
-          sessionId: input.sessionId ?? null,
-          prompt: input.prompt,
-          slots: [],
-          updatedAt: nowIso(),
-        };
+    const scopeId = variantScopeIdFor(input);
+    const previous = await readVariantStateUnlocked(scopeId);
+    const state =
+      previous && isSameVariantScope(previous, input)
+        ? previous
+        : {
+            runId: input.runId,
+            batchId: input.batchId ?? null,
+            libraryId: input.libraryId,
+            collectionId: input.collectionId,
+            presetId: input.presetId ?? null,
+            sessionId: input.sessionId ?? null,
+            threadId: input.threadId ?? null,
+            variantScopeId: scopeId,
+            prompt: input.prompt,
+            slots: [],
+            updatedAt: nowIso(),
+          };
 
     state.runId = input.runId;
     state.batchId = input.batchId ?? null;
     state.collectionId = input.collectionId ?? null;
     state.presetId = input.presetId ?? null;
     state.sessionId = input.sessionId ?? null;
+    state.threadId = input.threadId ?? null;
+    state.variantScopeId = scopeId;
     state.prompt = input.prompt;
 
     const now = nowIso();
@@ -97,14 +142,14 @@ export async function upsertVariantSlot(input: VariantSlotInput) {
     else state.slots.push(nextSlot);
 
     state.updatedAt = now;
-    await writeVariantStateUnlocked(state);
+    await writeVariantStateUnlocked(state, scopeId);
   });
 }
 
 function isSameVariantScope(
   previous: AssetVariantState | null,
-  input: VariantSlotInput,
-): previous is AssetVariantState {
+  input: VariantScopeInput,
+): boolean {
   if (!previous) return false;
 
   // The batch/run id is the generation boundary: batch slots may have distinct
@@ -122,20 +167,78 @@ function variantScopeId(input: { batchId?: string | null; runId: string }) {
   return input.batchId ?? input.runId;
 }
 
-async function readVariantStateUnlocked(): Promise<AssetVariantState | null> {
-  const current = (await readAppState("asset-variants")) as unknown | null;
+export async function readVariantState(
+  scopeId?: string | null,
+): Promise<AssetVariantState | null> {
+  return withVariantStateLock(() => readVariantStateUnlocked(scopeId));
+}
+
+export async function writeVariantState(
+  state: AssetVariantState,
+  scopeId?: string | null,
+) {
+  await withVariantStateLock(() => writeVariantStateUnlocked(state, scopeId));
+}
+
+export async function deleteVariantState(scopeId?: string | null) {
+  await withVariantStateLock(() => deleteVariantStateUnlocked(scopeId));
+}
+
+async function readVariantStateUnlocked(
+  scopeId?: string | null,
+): Promise<AssetVariantState | null> {
+  const key = variantStateKey(scopeId);
+  const current = (await readAppState(key)) as unknown | null;
+  if (current) return current as AssetVariantState;
+
+  if (scopeId) {
+    const globalCurrent = (await readAppState(GLOBAL_VARIANT_STATE_KEY)) as
+      | unknown
+      | null;
+    const globalState = (globalCurrent ?? null) as AssetVariantState | null;
+    return globalState?.threadId === scopeId ||
+      globalState?.variantScopeId === scopeId
+      ? globalState
+      : null;
+  }
+
   const legacyCurrent =
     current ??
-    ((await readAppState("image-variants").catch(() => null)) as
+    ((await readAppState(LEGACY_VARIANT_STATE_KEY).catch(() => null)) as
       | unknown
       | null);
   return (legacyCurrent ?? null) as AssetVariantState | null;
 }
 
-async function writeVariantStateUnlocked(state: AssetVariantState) {
-  await writeAppState(
-    "asset-variants",
-    state as unknown as Record<string, unknown>,
-  );
-  await deleteAppState("image-variants").catch(() => {});
+async function writeVariantStateUnlocked(
+  state: AssetVariantState,
+  scopeId?: string | null,
+) {
+  const key = variantStateKey(scopeId);
+  await writeAppState(key, state as unknown as Record<string, unknown>);
+  if (key !== GLOBAL_VARIANT_STATE_KEY) {
+    await writeAppState(
+      GLOBAL_VARIANT_STATE_KEY,
+      state as unknown as Record<string, unknown>,
+    );
+  }
+  await deleteAppState(LEGACY_VARIANT_STATE_KEY).catch(() => {});
+}
+
+async function deleteVariantStateUnlocked(scopeId?: string | null) {
+  const key = variantStateKey(scopeId);
+  await deleteAppState(key);
+  if (key !== GLOBAL_VARIANT_STATE_KEY) {
+    const globalCurrent = (await readAppState(GLOBAL_VARIANT_STATE_KEY)) as
+      | unknown
+      | null;
+    const globalState = (globalCurrent ?? null) as AssetVariantState | null;
+    if (
+      globalState?.threadId === scopeId ||
+      globalState?.variantScopeId === scopeId
+    ) {
+      await deleteAppState(GLOBAL_VARIANT_STATE_KEY);
+    }
+  }
+  await deleteAppState(LEGACY_VARIANT_STATE_KEY).catch(() => {});
 }

package/corpus/templates/assets/actions/view-screen.ts

@@ -71,6 +71,15 @@ export default defineAction({
         });
       }
     }
+    if (nav?.view === "library" && nav?.selection === "all") {
+      screen.libraries = await listLibraries.run({ compact: false });
+      screen.assets = await listAssets.run({
+        query:
+          typeof nav.search === "string" && nav.search.trim()
+            ? nav.search
+            : undefined,
+      });
+    }
     if (nav?.view === "audit") {
       screen.audit = await listAuditRuns.run({ limit: 20 });
     }