@agent-native/core 0.90.3 → 0.90.5

package/corpus/core/src/history/store.ts

@@ -1,4 +1,9 @@
-import { getDbExec, intType, isPostgres } from "../db/client.js";
+import {
+  getDbExec,
+  intType,
+  isPostgres,
+  isUniqueViolation,
+} from "../db/client.js";
 import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
 import type { Visibility } from "../sharing/schema.js";
 import type {
@@ -9,6 +14,8 @@ import type {
 
 let historyTableInitPromise: Promise<void> | undefined;
 
+const VERSION_INSERT_MAX_ATTEMPTS = 8;
+
 export interface InsertResourceVersionInput {
   resourceType: string;
   resourceId: string;
@@ -53,7 +60,7 @@ export async function ensureResourceVersionsTable(): Promise<void> {
       metadata_json TEXT
     )`;
       const indexes = [
-        `CREATE INDEX IF NOT EXISTS idx_agent_resource_versions_resource
+        `CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_resource_versions_resource_number
            ON agent_resource_versions (resource_type, resource_id, version_number)`,
         `CREATE INDEX IF NOT EXISTS idx_agent_resource_versions_owner
            ON agent_resource_versions (owner_email, created_at)`,
@@ -64,7 +71,7 @@ export async function ensureResourceVersionsTable(): Promise<void> {
       if (isPostgres()) {
         await ensureTableExists("agent_resource_versions", createSql);
         await ensureIndexExists(
-          "idx_agent_resource_versions_resource",
+          "idx_agent_resource_versions_resource_number",
           indexes[0],
         );
         await ensureIndexExists(
@@ -89,41 +96,55 @@ export async function insertResourceVersion(
 ): Promise<ResourceVersion> {
   await ensureResourceVersionsTable();
   const client = getDbExec();
-  const maxRows = await client.execute({
-    sql: `SELECT MAX(version_number) as max_version
+  const visibility =
+    input.visibility === "org" || input.visibility === "public"
+      ? input.visibility
+      : "private";
+  const actorKind = input.actorKind ?? "human";
+  const createdBy = input.createdBy ?? null;
+  const ownerEmail = input.ownerEmail ?? input.createdBy ?? null;
+  const orgId = input.orgId ?? null;
+  const title = input.title ?? null;
+  const summary = input.summary ?? null;
+  const metadata = input.metadata ?? null;
+  const snapshotJson = JSON.stringify(input.snapshot);
+  const metadataJson = stringifyOptionalJson(metadata);
+
+  let lastError: unknown;
+  for (let attempt = 0; attempt < VERSION_INSERT_MAX_ATTEMPTS; attempt++) {
+    const maxRows = await client.execute({
+      sql: `SELECT MAX(version_number) as max_version
        FROM agent_resource_versions
       WHERE resource_type = ? AND resource_id = ?`,
-    args: [input.resourceType, input.resourceId],
-  });
-  const versionNumber =
-    Number(
-      (maxRows.rows?.[0] as Record<string, unknown> | undefined)?.max_version ??
-        0,
-    ) + 1;
-  const id = createVersionId();
-  const createdAt = new Date().toISOString();
-  const version: ResourceVersion = {
-    id,
-    resourceType: input.resourceType,
-    resourceId: input.resourceId,
-    versionNumber,
-    createdAt,
-    createdBy: input.createdBy ?? null,
-    actorKind: input.actorKind ?? "human",
-    ownerEmail: input.ownerEmail ?? input.createdBy ?? null,
-    orgId: input.orgId ?? null,
-    visibility:
-      input.visibility === "org" || input.visibility === "public"
-        ? input.visibility
-        : "private",
-    title: input.title ?? null,
-    summary: input.summary ?? null,
-    snapshot: input.snapshot,
-    metadata: input.metadata ?? null,
-  };
+      args: [input.resourceType, input.resourceId],
+    });
+    const versionNumber =
+      Number(
+        (maxRows.rows?.[0] as Record<string, unknown> | undefined)
+          ?.max_version ?? 0,
+      ) + 1;
+    const id = createVersionId();
+    const createdAt = new Date().toISOString();
+    const version: ResourceVersion = {
+      id,
+      resourceType: input.resourceType,
+      resourceId: input.resourceId,
+      versionNumber,
+      createdAt,
+      createdBy,
+      actorKind,
+      ownerEmail,
+      orgId,
+      visibility,
+      title,
+      summary,
+      snapshot: input.snapshot,
+      metadata,
+    };
 
-  await client.execute({
-    sql: `INSERT INTO agent_resource_versions (
+    try {
+      await client.execute({
+        sql: `INSERT INTO agent_resource_versions (
       id,
       resource_type,
       resource_id,
@@ -139,25 +160,35 @@ export async function insertResourceVersion(
       snapshot_json,
       metadata_json
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    args: [
-      version.id,
-      version.resourceType,
-      version.resourceId,
-      version.versionNumber,
-      version.createdAt,
-      version.createdBy,
-      version.actorKind,
-      version.ownerEmail,
-      version.orgId,
-      version.visibility,
-      version.title,
-      version.summary,
-      JSON.stringify(version.snapshot),
-      stringifyOptionalJson(version.metadata),
-    ],
-  });
+        args: [
+          version.id,
+          version.resourceType,
+          version.resourceId,
+          version.versionNumber,
+          version.createdAt,
+          version.createdBy,
+          version.actorKind,
+          version.ownerEmail,
+          version.orgId,
+          version.visibility,
+          version.title,
+          version.summary,
+          snapshotJson,
+          metadataJson,
+        ],
+      });
+      return version;
+    } catch (error) {
+      lastError = error;
+      if (!isUniqueViolation(error)) {
+        throw error;
+      }
+    }
+  }
 
-  return version;
+  throw lastError instanceof Error
+    ? lastError
+    : new Error("Failed to allocate a unique resource version number");
 }
 
 export async function queryResourceVersions(

package/corpus/core/src/review/actions/consume-review-feedback.ts

@@ -23,11 +23,21 @@ export default defineAction({
       actionCtx,
       "editor",
     );
-    await consumeReviewFeedback(args.commentIds, undefined, {
-      resourceType: args.resourceType,
-      resourceId: args.resourceId,
-    });
-    return { consumedCommentIds: args.commentIds };
+    const updatedCount = await consumeReviewFeedback(
+      args.commentIds,
+      undefined,
+      {
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+      },
+    );
+    if (updatedCount < 1) {
+      throw new Error("No matching review comments to consume");
+    }
+    return {
+      consumedCommentIds: args.commentIds,
+      updatedCount,
+    };
   },
   audit: {
     target: (args) => ({

package/corpus/core/src/review/actions/delete-review-comment.ts

@@ -39,12 +39,19 @@ export default defineAction({
     }
     const isAuthor =
       Boolean(actionCtx?.userEmail) &&
-      comment.authorEmail === actionCtx?.userEmail;
+      normalizeEmail(comment.authorEmail) ===
+        normalizeEmail(actionCtx?.userEmail);
     if (!isAuthor && (!access || !roleSatisfies(access.role, "editor"))) {
       throw new ForbiddenError("Not allowed to delete this review comment");
     }
-    await deleteReviewComment(comment.id, actionCtx?.userEmail ?? null);
-    return { commentId: comment.id, deleted: true };
+    const updatedCount = await deleteReviewComment(
+      comment.id,
+      actionCtx?.userEmail ?? null,
+    );
+    if (updatedCount < 1) {
+      throw new Error("Review comment not found");
+    }
+    return { commentId: comment.id, deleted: true as const, updatedCount };
   },
   audit: {
     target: (args) => ({
@@ -53,3 +60,8 @@ export default defineAction({
     }),
   },
 });
+
+function normalizeEmail(email: string | null | undefined): string | null {
+  const normalized = email?.trim().toLowerCase();
+  return normalized || null;
+}

package/corpus/core/src/review/actions/resolve-review-thread.ts

@@ -45,11 +45,18 @@ export default defineAction({
     if (!threadId) {
       throw new Error("Provide threadId or commentId");
     }
-    await resolveReviewThread(threadId, actionCtx?.userEmail ?? null, {
-      resourceType: args.resourceType,
-      resourceId: args.resourceId,
-    });
-    return { threadId, resolved: true };
+    const updatedCount = await resolveReviewThread(
+      threadId,
+      actionCtx?.userEmail ?? null,
+      {
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+      },
+    );
+    if (updatedCount < 1) {
+      throw new Error("Review thread not found");
+    }
+    return { threadId, resolved: true as const, updatedCount };
   },
   audit: {
     target: (args) => ({

package/corpus/core/src/review/index.ts

@@ -24,13 +24,8 @@ export {
 } from "./registry.js";
 export {
   __resetReviewInitForTests,
-  consumeReviewFeedback,
-  deleteReviewComment,
   ensureReviewTables,
   getReviewCommentById,
   getReviewStatus,
-  insertReviewComment,
   queryReviewComments,
-  resolveReviewThread,
-  upsertReviewStatus,
 } from "./store.js";

package/corpus/core/src/review/registry.ts

@@ -1,4 +1,8 @@
-import { ForbiddenError, resolveAccess } from "../sharing/access.js";
+import {
+  ForbiddenError,
+  resolveAccess,
+  type AccessContext,
+} from "../sharing/access.js";
 import { getShareableResource } from "../sharing/registry.js";
 import { roleSatisfies, type Visibility } from "../sharing/schema.js";
 import type {
@@ -31,6 +35,16 @@ export function listReviewableResources(): ReviewableResourceRegistration[] {
   return Array.from(registrations.values());
 }
 
+function accessContextFrom(
+  ctx?: ReviewResourceContext,
+): AccessContext | undefined {
+  if (!ctx) return undefined;
+  return {
+    userEmail: ctx.userEmail ?? undefined,
+    orgId: ctx.orgId ?? undefined,
+  };
+}
+
 export async function resolveReviewableResourceAccess(
   resourceType: string,
   resourceId: string,
@@ -42,7 +56,11 @@ export async function resolveReviewableResourceAccess(
   }
 
   if (getShareableResource(resourceType)) {
-    const access = await resolveAccess(resourceType, resourceId);
+    const access = await resolveAccess(
+      resourceType,
+      resourceId,
+      accessContextFrom(ctx),
+    );
     if (!access) {
       return null;
     }
@@ -55,16 +73,10 @@ export async function resolveReviewableResourceAccess(
     };
   }
 
-  const userEmail = ctx?.userEmail ?? null;
-  if (!userEmail) {
-    return null;
-  }
-  return {
-    role: "owner",
-    ownerEmail: userEmail,
-    orgId: ctx?.orgId ?? null,
-    visibility: "private",
-  };
+  // Fail closed: unregistered types, and registered types without an access
+  // resolver that aren't shareable, never invent ownership. bypassScope on
+  // review queries is only safe after a real resource ACL.
+  return null;
 }
 
 export async function assertReviewableResourceAccess(

package/corpus/core/src/review/store.ts

@@ -310,13 +310,13 @@ export async function resolveReviewThread(
   threadId: string,
   resolvedBy?: string | null,
   resource?: { resourceType: string; resourceId: string },
-): Promise<void> {
+): Promise<number> {
   await ensureReviewTables();
   const now = new Date().toISOString();
   const resourceClause = resource
     ? "AND resource_type = ? AND resource_id = ?"
     : "";
-  await getDbExec().execute({
+  const result = await getDbExec().execute({
     sql: `UPDATE agent_review_comments
         SET status = 'resolved',
             resolved_by = ?,
@@ -331,15 +331,16 @@ export async function resolveReviewThread(
       ...(resource ? [resource.resourceType, resource.resourceId] : []),
     ],
   });
+  return result.rowsAffected ?? 0;
 }
 
 export async function deleteReviewComment(
   id: string,
   deletedBy?: string | null,
-): Promise<void> {
+): Promise<number> {
   await ensureReviewTables();
   const now = new Date().toISOString();
-  await getDbExec().execute({
+  const result = await getDbExec().execute({
     sql: `UPDATE agent_review_comments
         SET status = 'deleted',
             deleted_by = ?,
@@ -348,22 +349,23 @@ export async function deleteReviewComment(
       WHERE id = ?`,
     args: [deletedBy ?? null, now, now, id],
   });
+  return result.rowsAffected ?? 0;
 }
 
 export async function consumeReviewFeedback(
   ids: string[],
   consumedAt = new Date().toISOString(),
   resource?: { resourceType: string; resourceId: string },
-): Promise<void> {
+): Promise<number> {
   if (!ids.length) {
-    return;
+    return 0;
   }
   await ensureReviewTables();
   const placeholders = ids.map(() => "?").join(", ");
   const resourceClause = resource
     ? "AND resource_type = ? AND resource_id = ?"
     : "";
-  await getDbExec().execute({
+  const result = await getDbExec().execute({
     sql: `UPDATE agent_review_comments
         SET consumed_at = ?,
             updated_at = ?
@@ -375,6 +377,7 @@ export async function consumeReviewFeedback(
       ...(resource ? [resource.resourceType, resource.resourceId] : []),
     ],
   });
+  return result.rowsAffected ?? 0;
 }
 
 export async function upsertReviewStatus(

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -6623,6 +6623,12 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
               scope: "user",
               scopeId: ownerEmail,
             });
+            const { clearProviderCredentialAuthFailure } =
+              await import("./credential-provider.js");
+            await clearProviderCredentialAuthFailure({
+              key: secretKey,
+              value: trimmedKey,
+            });
           } catch (err) {
             console.error(
               "[agent-chat] save-key persistence failed:",

package/corpus/core/src/server/credential-provider.ts

@@ -721,6 +721,8 @@ export async function clearBuilderCredentialAuthFailure(creds: {
 }
 
 const PROVIDER_AUTH_FAILURE_SETTING_PREFIX = "provider-auth-failure:";
+/** Stale failure markers expire so a transient 401 cannot permanently block deploy keys. */
+export const PROVIDER_AUTH_FAILURE_TTL_MS = 15 * 60 * 1000;
 
 export interface ProviderCredentialAuthFailure {
   fingerprint: string;
@@ -760,10 +762,18 @@ export async function getProviderCredentialAuthFailure(opts: {
   const fingerprint = providerCredentialFingerprint(key, opts.value);
   if (!fingerprint) return null;
   try {
-    const { getSetting } = await import("../settings/store.js");
-    const row = await getSetting(providerAuthFailureSettingKey(fingerprint));
+    const settings = await import("../settings/store.js");
+    const settingKey = providerAuthFailureSettingKey(fingerprint);
+    const row = await settings.getSetting(settingKey);
     if (!row) return null;
     if (row.fingerprint !== fingerprint) return null;
+    const at = typeof row.at === "number" ? row.at : Date.now();
+    if (Date.now() - at > PROVIDER_AUTH_FAILURE_TTL_MS) {
+      if (typeof settings.deleteSetting === "function") {
+        await settings.deleteSetting(settingKey).catch(() => {});
+      }
+      return null;
+    }
     return {
       fingerprint,
       key:
@@ -776,7 +786,7 @@ export async function getProviderCredentialAuthFailure(opts: {
           : "The model provider rejected the saved API key.",
       status: typeof row.status === "number" ? row.status : undefined,
       code: typeof row.code === "string" ? row.code : undefined,
-      at: typeof row.at === "number" ? row.at : Date.now(),
+      at,
       ownerEmail:
         typeof row.ownerEmail === "string" ? row.ownerEmail : undefined,
       orgId: typeof row.orgId === "string" ? row.orgId : undefined,

package/corpus/templates/assets/actions/_preset-skeleton-validation.ts

@@ -25,8 +25,11 @@ export async function assertPresetSkeletonAssetsValid(input: {
     skeleton.mask?.type === "asset" && typeof skeleton.mask.assetId === "string"
       ? skeleton.mask.assetId
       : "";
-  if (!backgroundAssetId || !maskAssetId) return;
+  if (!backgroundAssetId) return;
 
+  const assetIds = maskAssetId
+    ? [backgroundAssetId, maskAssetId]
+    : [backgroundAssetId];
   const rows = await input.db
     .select({
       id: schema.assets.id,
@@ -35,18 +38,15 @@ export async function assertPresetSkeletonAssetsValid(input: {
       height: schema.assets.height,
     })
     .from(schema.assets)
-    .where(inArray(schema.assets.id, [backgroundAssetId, maskAssetId]));
+    .where(inArray(schema.assets.id, assetIds));
   const background = rows.find((asset: any) => asset.id === backgroundAssetId);
+  if (!background || background.libraryId !== input.libraryId) {
+    throw new Error("Skeleton image must belong to this asset library.");
+  }
+  if (!maskAssetId) return;
   const mask = rows.find((asset: any) => asset.id === maskAssetId);
-  if (
-    !background ||
-    !mask ||
-    background.libraryId !== input.libraryId ||
-    mask.libraryId !== input.libraryId
-  ) {
-    throw new Error(
-      "Skeleton image and mask must belong to this asset library.",
-    );
+  if (!mask || mask.libraryId !== input.libraryId) {
+    throw new Error("Skeleton mask must belong to this asset library.");
   }
   if (
     typeof background.width !== "number" ||

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

@@ -30,9 +30,11 @@ import {
   compositeLogo,
   maskFromManualMaskAlpha,
   maskFromPlateAlpha,
+  prepareGptImage2SkeletonInpaintImages,
 } from "../server/lib/image-processing.js";
 import { nowIso, parseJson, stringifyJson } from "../server/lib/json.js";
 import {
+  aspectRatioValue,
   clampCutoutAspectRatio,
   normalizePresetSkeletonSpec,
   skeletonUsesCanonicalLogo,
@@ -350,13 +352,21 @@ export default defineAction({
       isSkeletonCutout &&
       Boolean(skeletonAssets?.backgroundAsset) &&
       resolvedModel === "gpt-image-2";
+    const skeletonInpaint = useSkeletonInpaint
+      ? await inpaintReferencesForSkeleton(skeletonAssets)
+      : null;
     const resolvedAspectRatio =
-      isSkeletonCutout && !useSkeletonInpaint
-        ? clampCutoutAspectRatio({
-            aspectRatio: outputAspectRatio,
-            supported: supportedAspectRatiosForModel("gpt-image-1"),
-          })
-        : outputAspectRatio;
+      useSkeletonInpaint && skeletonInpaint
+        ? closestSupportedAspectRatioForSize(
+            skeletonInpaint.size,
+            supportedAspectRatiosForModel("gpt-image-2"),
+          )
+        : isSkeletonCutout
+          ? clampCutoutAspectRatio({
+              aspectRatio: outputAspectRatio,
+              supported: supportedAspectRatiosForModel("gpt-image-1"),
+            })
+          : outputAspectRatio;
     if (
       isSkeletonCutout &&
       !useSkeletonInpaint &&
@@ -386,7 +396,7 @@ export default defineAction({
       : "";
     let references: ReferenceForGeneration[];
     if (useSkeletonInpaint) {
-      references = await inpaintReferencesForSkeleton(skeletonAssets);
+      references = skeletonInpaint?.references ?? [];
     } else {
       const backgroundPlateReference =
         backgroundPlateReferenceForSkeleton(skeletonAssets);
@@ -839,7 +849,10 @@ function backgroundPlateReferenceForSkeleton(
 
 async function inpaintReferencesForSkeleton(
   skeletonAssets: LoadedSkeletonAssets | null,
-): Promise<ReferenceForGeneration[]> {
+): Promise<{
+  references: ReferenceForGeneration[];
+  size: { width: number; height: number };
+}> {
   if (
     !skeletonAssets?.backgroundAsset ||
     !skeletonAssets.backgroundAssetId ||
@@ -853,26 +866,49 @@ async function inpaintReferencesForSkeleton(
         plate: skeletonAssets.backgroundAsset,
       })
     : await maskFromPlateAlpha(skeletonAssets.backgroundAsset);
-  return [
-    {
-      id: skeletonAssets.backgroundAssetId,
-      role: "edit_target",
-      category: "skeleton",
-      mimeType: skeletonAssets.backgroundMimeType,
-      data: skeletonAssets.backgroundAsset.toString("base64"),
-      selectionReason: "explicit",
-    },
-    {
-      id:
-        skeletonAssets.maskAssetId ??
-        `${skeletonAssets.backgroundAssetId}:mask`,
-      role: "mask",
-      category: "skeleton",
-      mimeType: "image/png",
-      data: mask.toString("base64"),
-      selectionReason: "explicit",
-    },
-  ];
+  const prepared = await prepareGptImage2SkeletonInpaintImages({
+    plate: skeletonAssets.backgroundAsset,
+    mask,
+  });
+  return {
+    size: prepared.size,
+    references: [
+      {
+        id: skeletonAssets.backgroundAssetId,
+        role: "edit_target",
+        category: "skeleton",
+        mimeType: prepared.resized
+          ? "image/png"
+          : skeletonAssets.backgroundMimeType,
+        data: prepared.plate.toString("base64"),
+        selectionReason: "explicit",
+      },
+      {
+        id:
+          skeletonAssets.maskAssetId ??
+          `${skeletonAssets.backgroundAssetId}:mask`,
+        role: "mask",
+        category: "skeleton",
+        mimeType: "image/png",
+        data: prepared.mask.toString("base64"),
+        selectionReason: "explicit",
+      },
+    ],
+  };
+}
+
+function closestSupportedAspectRatioForSize(
+  size: { width: number; height: number },
+  supported: readonly AspectRatio[],
+): AspectRatio {
+  const target = size.width / size.height;
+  return (
+    [...supported].sort(
+      (left, right) =>
+        Math.abs(aspectRatioValue(left) - target) -
+        Math.abs(aspectRatioValue(right) - target),
+    )[0] ?? "1:1"
+  );
 }
 
 type LoadedSkeletonAssets = {

package/corpus/templates/assets/app/components/generation/GenerationResults.tsx

@@ -44,7 +44,7 @@ function variantStateKey(threadId: string | null) {
 // STALE_IMAGE_RUN_MS in refresh-generation-run, so a slow-but-healthy run (e.g.
 // gpt-image-2) is not flagged "interrupted" and flipped to an error slot before
 // its finished image arrives.
-const STALE_PENDING_RUN_MS = 6 * 60 * 1000;
+const STALE_PENDING_RUN_MS = 10 * 60 * 1000;
 
 function slotTime(slot: AssetVariantState["slots"][number]): number {
   const raw = slot.createdAt ?? slot.updatedAt ?? "";