@agent-native/core 0.77.24 → 0.78.1

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 });
     }