@agent-native/core 0.80.9 → 0.80.11

package/corpus/templates/assets/server/lib/generation.ts

@@ -11,6 +11,7 @@ import type {
   GenerationIntent,
   ImageCategory,
   ImageModel,
+  ImageQualityTier,
   ImageSize,
   StyleStrength,
   StyleBrief,
@@ -564,7 +565,8 @@ export async function analyzeStyleWithGemini(input: {
       {
         text: [
           "Analyze these brand/style reference images for a reusable image generation style brief.",
-          "Return only compact JSON with keys: description, medium, mood, subjectMatter, texture, composition, lighting, typographyPolicy, doNot.",
+          "Return only compact JSON with keys: description, medium, mood, subjectMatter, texture, composition, lighting, fontFamilies, fontWeights, letterforms, caseStyle, typographyPolicy, doNot.",
+          "For typography, describe specific letterforms and font traits, not just broad sans/serif categories; omit any typography field you cannot determine confidently.",
           "Use specific trait-locking phrases that can be reused across future image prompts.",
           "Do not name brands, artists, studios, franchises, or copyrighted works unless they appear as user-provided brand identity.",
           "Keep doNot as an array of short constraints. Omit uncertain fields instead of guessing.",
@@ -608,16 +610,24 @@ function extractJsonObject(text: string): string {
   return "{}";
 }
 
-function sanitizeStyleBrief(value: Record<string, unknown>): StyleBrief {
+export function sanitizeStyleBrief(value: Record<string, unknown>): StyleBrief {
   const stringField = (key: string) => {
     const raw = value[key];
     return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
   };
-  const doNot = Array.isArray(value.doNot)
-    ? value.doNot.filter(
-        (item): item is string => typeof item === "string" && !!item.trim(),
-      )
-    : undefined;
+  const stringArrayField = (key: string) => {
+    const raw = value[key];
+    return Array.isArray(raw)
+      ? raw
+          .filter(
+            (item): item is string => typeof item === "string" && !!item.trim(),
+          )
+          .map((item) => item.trim())
+      : undefined;
+  };
+  const fontFamilies = stringArrayField("fontFamilies");
+  const fontWeights = stringArrayField("fontWeights");
+  const doNot = stringArrayField("doNot");
   return {
     description: stringField("description"),
     medium: stringField("medium"),
@@ -626,8 +636,12 @@ function sanitizeStyleBrief(value: Record<string, unknown>): StyleBrief {
     texture: stringField("texture"),
     composition: stringField("composition"),
     lighting: stringField("lighting"),
+    fontFamilies: fontFamilies?.length ? fontFamilies : undefined,
+    fontWeights: fontWeights?.length ? fontWeights : undefined,
+    letterforms: stringField("letterforms"),
+    caseStyle: stringField("caseStyle"),
     typographyPolicy: stringField("typographyPolicy"),
-    doNot: doNot?.length ? doNot.map((item) => item.trim()) : undefined,
+    doNot: doNot?.length ? doNot : undefined,
   };
 }
 
@@ -774,6 +788,66 @@ function toBuilderImageModel(model: ImageModel) {
   return model;
 }
 
+function resolveModelForTier(
+  tier: ImageQualityTier | undefined,
+  category: ImageCategory | undefined,
+): ImageModel | undefined {
+  if (!tier) return undefined;
+  if (tier === "fast") return "gemini-3.1-flash-image";
+  if (tier === "best") return "gemini-3-pro-image";
+  return ["hero", "landing", "logo", "campaign"].includes(category ?? "")
+    ? "gemini-3-pro-image"
+    : "gemini-3.1-flash-image";
+}
+
+export function resolveImageModelForRequest(input: {
+  explicitModel?: ImageModel;
+  imageModelDefault?: ImageModel;
+  explicitTier?: ImageQualityTier;
+  resolvedTier?: ImageQualityTier;
+  category?: ImageCategory;
+  presetModel?: ImageModel | null;
+  embeddedText?: string | null;
+}): ImageModel {
+  if (input.explicitModel) return input.explicitModel;
+
+  // Exact embedded text is materially better on Gemini Pro, so upgrade to it by
+  // default for text requests — but never override a model or tier the caller
+  // or a tagged preset already chose (presets "own" model/tier per the action
+  // docs). Only auto-upgrade when there is no tier (explicit or preset-derived)
+  // and no preset model in play; this still upgrades a bare text request over
+  // the composer default.
+  const textAccurateModel: ImageModel | undefined =
+    input.embeddedText?.trim() &&
+    !input.explicitTier &&
+    !input.resolvedTier &&
+    !input.presetModel
+      ? "gemini-3-pro-image"
+      : undefined;
+
+  // Precedence: explicit per-request model (handled above) > embedded-text
+  // upgrade > an EXPLICIT per-request tier > the preset's saved model > the
+  // preset-DERIVED tier mapping > the sticky composer default > the floor.
+  //
+  // Two subtleties:
+  //   - An explicit per-request tier outranks the preset's saved model (the
+  //     caller is deliberately overriding the preset this turn).
+  //   - The preset's explicit saved model outranks its OWN derived tier: a
+  //     preset's `model` column and `settings.tier` can drift out of sync
+  //     (update-generation-preset can change one without the other), and the
+  //     explicitly saved model is the authoritative choice.
+  //   - The composer default ranks LAST of the real signals: it is a global
+  //     stored preference and must not defeat a tagged preset or a tier request.
+  return (
+    textAccurateModel ??
+    resolveModelForTier(input.explicitTier, input.category) ??
+    input.presetModel ??
+    resolveModelForTier(input.resolvedTier, input.category) ??
+    input.imageModelDefault ??
+    "gemini-3.1-flash-image"
+  );
+}
+
 function toBuilderReferenceRole(role: string) {
   switch (role) {
     case "style_reference":
@@ -799,6 +873,8 @@ export function compilePrompt(input: {
   styleBrief: StyleBrief;
   customInstructions?: string | null;
   prompt: string;
+  embeddedText?: string | null;
+  textPlacement?: string | null;
   referenceCount: number;
   includeLogo: boolean;
   aspectRatio?: AspectRatio;
@@ -815,6 +891,11 @@ export function compilePrompt(input: {
   const doNot = style.doNot?.length
     ? `\nAvoid: ${style.doNot.join("; ")}.`
     : "";
+  const typographyBlock = formatBrandTypography(style);
+  const requestedEmbeddedText = hasEmbeddedText(input.embeddedText);
+  const textInstruction = requestedEmbeddedText
+    ? formatEmbeddedTextInstruction(input.embeddedText, input.textPlacement)
+    : "Do not render headlines, body text, UI labels, or prompt wording inside the image unless the user explicitly asks for exact visible text.";
   const logoInstruction = input.includeLogo
     ? "\nLeave a clean uncluttered area in the upper-right for the real brand logo; do not draw or approximate the logo yourself."
     : "";
@@ -839,14 +920,24 @@ export function compilePrompt(input: {
           : "No reference images are attached for this run. Use the style brief and custom instructions as the source of truth.";
 
   if (intent === "edit") {
+    const editTypographyInstruction =
+      requestedEmbeddedText && typographyBlock ? `\n\n${typographyBlock}` : "";
+    const editTextInstruction = requestedEmbeddedText
+      ? `\n\n${formatEmbeddedTextInstruction(input.embeddedText, input.textPlacement)}`
+      : "";
+    const editConstraint = requestedEmbeddedText
+      ? "Do not reimagine the image, change its aspect ratio, or alter unrelated subjects. Do not add any other new text. Return the full image."
+      : "Do not reimagine the image, change its aspect ratio, add new text, or alter unrelated subjects. Return the full image.";
     return `Edit the attached image for the "${input.libraryTitle}" asset library.
 
 ${referenceInstruction}
+${editTypographyInstruction}
 
 Make only this change:
 ${input.prompt}
+${editTextInstruction}
 
-Do not reimagine the image, change its aspect ratio, add new text, or alter unrelated subjects. Return the full image.`;
+${editConstraint}`;
   }
 
   return `Create a brand-consistent image for the "${input.libraryTitle}" asset library.
@@ -861,15 +952,48 @@ ${style.subjectMatter ? `\nSubject matter: ${style.subjectMatter}.` : ""}
 ${style.texture ? `\nTexture/material treatment: ${style.texture}.` : ""}
 ${style.composition ? `\nComposition: ${style.composition}.` : ""}
 ${style.lighting ? `\nLighting: ${style.lighting}.` : ""}
-${style.typographyPolicy ? `\nTypography policy: ${style.typographyPolicy}.` : ""}${frameInstruction}
+${typographyBlock ? `\n${typographyBlock}` : ""}${frameInstruction}
 ${doNot}${logoInstruction}${diagramInstruction}${customInstructions}
 
-Do not render headlines, body text, UI labels, or prompt wording inside the image unless the user explicitly asks for exact visible text.
+${textInstruction}
 
 User request:
 ${input.prompt}`;
 }
 
+function hasEmbeddedText(value?: string | null): boolean {
+  return typeof value === "string" && !!value.trim();
+}
+
+function formatEmbeddedTextInstruction(
+  embeddedText?: string | null,
+  textPlacement?: string | null,
+): string {
+  const placement = textPlacement?.trim();
+  return [
+    `Render this text exactly, spelled correctly, inside the image: ${JSON.stringify(embeddedText ?? "")}.`,
+    placement ? `Placement: ${placement}.` : "",
+    "Match the brand typography described above where specified; keep it legible and well-kerned.",
+  ]
+    .filter(Boolean)
+    .join(" ");
+}
+
+function formatBrandTypography(style: StyleBrief): string {
+  const parts = [
+    style.fontFamilies?.length
+      ? `families ${style.fontFamilies.join(", ")}`
+      : "",
+    style.fontWeights?.length ? `weights ${style.fontWeights.join(", ")}` : "",
+    style.letterforms ? `letterforms: ${style.letterforms}` : "",
+    style.caseStyle ? `case: ${style.caseStyle}` : "",
+    style.typographyPolicy,
+  ].filter((part): part is string => typeof part === "string" && !!part.trim());
+
+  if (!parts.length) return "";
+  return `Brand typography: ${parts.join("; ")}. Match these for any rendered text.`;
+}
+
 // A content-only reference is an image the user attached as subject/content for
 // a single request (not a reusable brand/style reference). It should never count
 // as a brand-kit style reference.

package/corpus/templates/assets/shared/api.ts

@@ -112,6 +112,10 @@ export interface StyleBrief {
   texture?: string;
   composition?: string;
   lighting?: string;
+  fontFamilies?: string[];
+  fontWeights?: string[];
+  letterforms?: string;
+  caseStyle?: string;
   typographyPolicy?: string;
   doNot?: string[];
 }

package/corpus/templates/clips/actions/list-ai-requests.ts

@@ -0,0 +1,60 @@
+/**
+ * List pending clips AI requests for the current user.
+ *
+ * Collapses the per-recording `clips-ai-request-<id>` polling done by the
+ * auto-title bridge into a single call. Application state is already
+ * session-scoped, and we additionally filter the referenced recordings through
+ * `accessFilter` so we never return a request for a recording the user can't
+ * access. Only requests for `status = "ready"` recordings are returned — the
+ * bridge ignores non-ready recordings, so excluding them avoids sending large
+ * transcript blobs for recordings the hook will skip this tick.
+ */
+
+import { defineAction } from "@agent-native/core";
+import { listAppState } from "@agent-native/core/application-state";
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, eq, inArray } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+
+const REQUEST_PREFIX = "clips-ai-request-";
+
+export default defineAction({
+  description:
+    "List pending clips AI requests (regenerate-title, summary, chapters, etc.) for recordings the current user can access.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  run: async () => {
+    const entries = await listAppState(REQUEST_PREFIX);
+
+    const requests = entries
+      .map((e) => e.value as Record<string, unknown>)
+      .filter(
+        (v): v is Record<string, unknown> & { recordingId: string } =>
+          !!v && typeof v.recordingId === "string" && v.recordingId.length > 0,
+      );
+
+    if (requests.length === 0) return { requests: [] };
+
+    const recordingIds = [...new Set(requests.map((r) => r.recordingId))];
+
+    const db = getDb();
+    const accessible = await db
+      .select({ id: schema.recordings.id })
+      .from(schema.recordings)
+      .where(
+        and(
+          accessFilter(schema.recordings, schema.recordingShares),
+          inArray(schema.recordings.id, recordingIds),
+          eq(schema.recordings.status, "ready"),
+        ),
+      );
+
+    const accessibleIds = new Set(accessible.map((r) => r.id));
+
+    return {
+      requests: requests.filter((r) => accessibleIds.has(r.recordingId)),
+    };
+  },
+});

package/corpus/templates/clips/app/hooks/use-auto-title.ts

@@ -1,8 +1,9 @@
 /**
  * Clips AI request bridge
  *
- * Watches the `clips-ai-request-:id` application_state queue. The bridge sends
- * queued recording work to the agent chat exactly once per
+ * Polls the `list-ai-requests` action — a single access-scoped call that returns
+ * every pending `clips-ai-request-*` entry for recordings the user can access.
+ * The bridge sends queued recording work to the agent chat exactly once per
  * (recordingId, kind, requestedAt).
  *
  * Once handled we DELETE the request entry so the next page load / tab switch
@@ -21,6 +22,7 @@ import { useRecordings, type RecordingSummary } from "./use-library";
 
 const DEFAULT_TITLE = "Untitled recording";
 const POLL_INTERVAL_MS = 3000;
+const TWO_MINUTES_MS = 2 * 60 * 1000;
 
 /** True when `title` is blank or equal to the server-seeded default. */
 export function isDefaultTitle(title: string | null | undefined): boolean {
@@ -62,22 +64,21 @@ const DISPATCHABLE_REQUESTS = new Set([
   "generate-workflow",
 ]);
 
-async function readRequest(recordingId: string): Promise<AiRequest | null> {
-  const url = agentNativePath(
-    `/_agent-native/application-state/${encodeURIComponent(
-      `clips-ai-request-${recordingId}`,
-    )}`,
-  );
+async function listRequests(): Promise<Map<string, AiRequest>> {
   try {
-    const res = await fetch(url);
-    if (!res.ok) return null;
-    const payload = await res.json().catch(() => null);
-    if (!payload || typeof payload !== "object") return null;
-    // The application-state endpoint wraps stored values under `.value`.
-    const value = (payload as any).value ?? payload;
-    return value as AiRequest;
+    const result = (await callAction("list-ai-requests", {} as any, {
+      method: "GET",
+    })) as { requests?: AiRequest[] } | null | undefined;
+    return new Map(
+      (result?.requests ?? [])
+        .filter(
+          (r): r is AiRequest & { recordingId: string } => !!r?.recordingId,
+        )
+        .map((r) => [r.recordingId, r]),
+    );
   } catch {
-    return null;
+    // Swallow — the next tick retries.
+    return new Map();
   }
 }
 
@@ -120,16 +121,15 @@ export function useAutoTitleBridge(): void {
       if (cancelled || inflight.current) return;
       inflight.current = true;
       try {
+        const requestsById = await listRequests();
+        if (cancelled) return;
+
         for (const rec of readyRecordings) {
           if (cancelled) return;
 
-          const request = await readRequest(rec.id);
+          const request = requestsById.get(rec.id) ?? null;
 
-          if (
-            request?.kind &&
-            DISPATCHABLE_REQUESTS.has(request.kind) &&
-            request.recordingId === rec.id
-          ) {
+          if (request?.kind && DISPATCHABLE_REQUESTS.has(request.kind)) {
             // Server queued a delegation — use the full context it provided.
             // Key includes requestedAt so each distinct server request fires
             // exactly once, independent of any prior fallback dispatch.
@@ -164,9 +164,8 @@ export function useAutoTitleBridge(): void {
               continue;
             }
 
-            const ageMs = Date.now() - new Date(rec.createdAt).getTime();
-            const TWO_MINUTES_MS = 2 * 60 * 1000;
-            if (ageMs < TWO_MINUTES_MS) continue;
+            if (Date.now() - new Date(rec.createdAt).getTime() < TWO_MINUTES_MS)
+              continue;
 
             // Use a dedicated key so a later server-queued request (e.g. from
             // a long transcription that finishes after the 2-min window) is