@agent-native/core 0.131.7 → 0.132.0

package/corpus/templates/clips/actions/reconcile-workflow-generation.ts

@@ -0,0 +1,257 @@
+import { defineAction } from "@agent-native/core";
+import {
+  compareAndSetAppState,
+  compareAndSetManyAppState,
+  readAppState,
+} from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import { WorkflowKindSchema } from "../shared/workflow.js";
+
+const WorkflowStateSchema = z
+  .object({
+    kind: WorkflowKindSchema.optional(),
+    status: z.string().optional(),
+    content: z.string().optional(),
+    recordingId: z.string().optional(),
+    requestedAt: z.string().optional(),
+    tabId: z.string().optional(),
+    claimedAt: z.string().optional(),
+  })
+  .passthrough();
+
+const WorkflowRequestSchema = z
+  .object({
+    requestedAt: z.string(),
+    deliveredAt: z.string().optional(),
+    deliveredTabId: z.string().optional(),
+  })
+  .passthrough();
+
+const CLAIM_LEASE_MS = 30_000;
+
+export default defineAction({
+  description:
+    "Track and reconcile the agent run responsible for a generated workflow.",
+  agentTool: false,
+  schema: z.object({
+    operation: z.enum([
+      "track",
+      "release",
+      "mark-delivered",
+      "consume",
+      "stop",
+    ]),
+    recordingId: z.string().min(1),
+    requestedAt: z.string().min(1),
+    tabId: z.string().min(1),
+  }),
+  run: async ({ operation, recordingId, requestedAt, tabId }) => {
+    await assertAccess("recording", recordingId, "viewer");
+
+    const requestKey = `clips-ai-request-${recordingId}`;
+    if (operation === "mark-delivered" || operation === "consume") {
+      const rawRequest = await readAppState(requestKey);
+      if (rawRequest === null) {
+        return operation === "consume"
+          ? { reconciled: false, consumed: true, reason: "missing" as const }
+          : { reconciled: false, delivered: true, reason: "missing" as const };
+      }
+      const parsedRequest = WorkflowRequestSchema.safeParse(rawRequest);
+      if (!parsedRequest.success) {
+        throw new Error(`Invalid workflow request state for ${recordingId}`);
+      }
+      if (parsedRequest.data.requestedAt !== requestedAt) {
+        return operation === "consume"
+          ? {
+              reconciled: false,
+              consumed: true,
+              reason: "newer-request" as const,
+            }
+          : {
+              reconciled: false,
+              delivered: true,
+              reason: "newer-request" as const,
+            };
+      }
+      if (operation === "mark-delivered") {
+        if (parsedRequest.data.deliveredTabId === tabId) {
+          return { reconciled: false, delivered: true };
+        }
+        if (parsedRequest.data.deliveredTabId) {
+          return {
+            reconciled: false,
+            delivered: false,
+            reason: "different-run" as const,
+          };
+        }
+
+        const stateKey = `clips-workflow-${recordingId}`;
+        const rawState = await readAppState(stateKey);
+        if (rawState === null) {
+          return { reconciled: false, delivered: false, reason: "missing" };
+        }
+        const parsedState = WorkflowStateSchema.safeParse(rawState);
+        if (!parsedState.success) {
+          throw new Error(
+            `Invalid generated workflow state for ${recordingId}`,
+          );
+        }
+        if (parsedState.data.status !== "generating") {
+          const consumed = await compareAndSetAppState(
+            requestKey,
+            rawRequest,
+            null,
+          );
+          return consumed
+            ? {
+                reconciled: false,
+                delivered: true,
+                consumed: true,
+                reason: "terminal",
+              }
+            : {
+                reconciled: false,
+                delivered: false,
+                consumed: false,
+                reason: "stale",
+              };
+        }
+        if (
+          parsedState.data.requestedAt !== requestedAt ||
+          parsedState.data.tabId !== tabId
+        ) {
+          return {
+            reconciled: false,
+            delivered: false,
+            reason: "different-run",
+          };
+        }
+
+        const deliveredAt = new Date().toISOString();
+        const delivered = await compareAndSetManyAppState([
+          {
+            key: stateKey,
+            expectedValue: rawState,
+            nextValue: { ...rawState, claimedAt: deliveredAt },
+          },
+          {
+            key: requestKey,
+            expectedValue: rawRequest,
+            nextValue: { ...rawRequest, deliveredAt, deliveredTabId: tabId },
+          },
+        ]);
+        return delivered
+          ? { reconciled: false, delivered: true }
+          : { reconciled: false, delivered: false, reason: "stale" as const };
+      }
+      if (parsedRequest.data.deliveredTabId !== tabId) {
+        return {
+          reconciled: false,
+          consumed: false,
+          reason: "not-delivered" as const,
+        };
+      }
+      const consumed = await compareAndSetAppState(
+        requestKey,
+        rawRequest,
+        null,
+      );
+      return consumed
+        ? { reconciled: false, consumed: true }
+        : { reconciled: false, consumed: false, reason: "stale" as const };
+    }
+
+    const stateKey = `clips-workflow-${recordingId}`;
+    const rawState = await readAppState(stateKey);
+    if (rawState === null) {
+      return { reconciled: false, reason: "missing" as const };
+    }
+
+    const parsedState = WorkflowStateSchema.safeParse(rawState);
+    if (!parsedState.success) {
+      throw new Error(`Invalid generated workflow state for ${recordingId}`);
+    }
+
+    const state = parsedState.data;
+    if (state.status !== "generating") {
+      return { reconciled: false, reason: "terminal" as const };
+    }
+    if (state.requestedAt !== requestedAt) {
+      return { reconciled: false, reason: "newer-request" as const };
+    }
+
+    if (operation === "track") {
+      if (state.tabId === tabId) {
+        return { reconciled: false, tracked: true };
+      }
+      if (state.tabId) {
+        const claimedAt = Date.parse(
+          state.claimedAt ?? state.requestedAt ?? "",
+        );
+        if (
+          !Number.isFinite(claimedAt) ||
+          Date.now() - claimedAt < CLAIM_LEASE_MS
+        ) {
+          return {
+            reconciled: false,
+            tracked: false,
+            reason: "claimed" as const,
+          };
+        }
+      }
+      const rawRequest = await readAppState(requestKey);
+      if (rawRequest === null) {
+        return { reconciled: false, reason: "request-missing" as const };
+      }
+      const parsedRequest = WorkflowRequestSchema.safeParse(rawRequest);
+      if (!parsedRequest.success) {
+        throw new Error(`Invalid workflow request state for ${recordingId}`);
+      }
+      if (parsedRequest.data.requestedAt !== requestedAt) {
+        return { reconciled: false, reason: "newer-request" as const };
+      }
+
+      const tracked = await compareAndSetAppState(stateKey, rawState, {
+        ...rawState,
+        tabId,
+        claimedAt: new Date().toISOString(),
+      });
+      return tracked
+        ? { reconciled: false, tracked: true }
+        : { reconciled: false, tracked: false, reason: "stale" as const };
+    }
+    if (state.tabId !== tabId) {
+      return operation === "release"
+        ? {
+            reconciled: false,
+            released: true,
+            reason: "different-run" as const,
+          }
+        : { reconciled: false, reason: "different-run" as const };
+    }
+    if (operation === "release") {
+      const untrackedState = { ...rawState };
+      delete untrackedState.tabId;
+      delete untrackedState.claimedAt;
+      const released = await compareAndSetAppState(
+        stateKey,
+        rawState,
+        untrackedState,
+      );
+      return released
+        ? { reconciled: false, released: true }
+        : { reconciled: false, released: false, reason: "stale" as const };
+    }
+
+    const reconciled = await compareAndSetAppState(stateKey, rawState, {
+      ...rawState,
+      status: "failed",
+      failedAt: new Date().toISOString(),
+    });
+    return reconciled
+      ? { reconciled: true }
+      : { reconciled: false, reason: "stale" as const };
+  },
+});

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

@@ -1,5 +1,7 @@
 import {
+  generateTabId,
   sendToAgentChat,
+  sendToAgentChatAndConfirm,
   type AgentChatMessage,
 } from "@agent-native/core/client/agent-chat";
 import { agentNativePath } from "@agent-native/core/client/api-path";
@@ -11,6 +13,8 @@ import { useRecordings, type RecordingSummary } from "./use-library";
 
 const DEFAULT_TITLE = "Untitled recording";
 const TWO_MINUTES_MS = 2 * 60 * 1000;
+export const WORKFLOW_ACTION_MAX_ATTEMPTS = 5;
+const WORKFLOW_ACTION_RETRY_DELAY_MS = 1000;
 
 /** True when `title` is blank or equal to the server-seeded default. */
 export function isDefaultTitle(title: string | null | undefined): boolean {
@@ -45,6 +49,8 @@ interface AiRequest {
   message?: string;
   includeFullVideoInAi?: boolean;
   openInChat?: boolean;
+  deliveredAt?: string;
+  deliveredTabId?: string;
 }
 
 const DISPATCHABLE_REQUESTS = new Set([
@@ -99,6 +105,36 @@ export function useAutoTitleBridge(): void {
   const dispatched = useRef<Set<string>>(new Set());
   const inflight = useRef<boolean>(false);
 
+  useEffect(() => {
+    const handleChatRunning = (event: Event) => {
+      const detail = (event as CustomEvent).detail;
+      if (
+        detail?.isRunning !== false ||
+        (detail.reason !== "stopped" && detail.reason !== "failed") ||
+        typeof detail.tabId !== "string"
+      )
+        return;
+
+      const recordingId = recordingIdFromTab(detail.tabId);
+      const requestedAt = requestedAtFromTab(detail.tabId);
+      if (!recordingId || !requestedAt) return;
+
+      void retryWorkflowAction(
+        {
+          operation: "stop",
+          recordingId,
+          requestedAt,
+          tabId: detail.tabId,
+        },
+        "reconciled",
+      );
+    };
+
+    window.addEventListener("agentNative.chatRunning", handleChatRunning);
+    return () =>
+      window.removeEventListener("agentNative.chatRunning", handleChatRunning);
+  }, []);
+
   const readyRecordings = recordings.filter((r) => r.status === "ready");
   const readyRecordingsKey = readyRecordings
     .map(
@@ -144,7 +180,6 @@ export function useAutoTitleBridge(): void {
               request.requestedAt ?? "0"
             }`;
             if (dispatched.current.has(dispatchKey)) continue;
-            dispatched.current.add(dispatchKey);
             if (
               request.kind === "generate-metadata" ||
               request.kind === "regenerate-title"
@@ -155,8 +190,67 @@ export function useAutoTitleBridge(): void {
               dispatched.current.add(`${rec.id}:fallback`);
             }
 
-            dispatchAiRequest(rec, request);
+            if (
+              request.kind === "generate-workflow" &&
+              typeof request.requestedAt === "string"
+            ) {
+              if (request.deliveredTabId) {
+                dispatched.current.add(dispatchKey);
+                void consumeWorkflowRequest({
+                  recordingId: rec.id,
+                  requestedAt: request.requestedAt,
+                  tabId: request.deliveredTabId,
+                });
+                continue;
+              }
 
+              const tabId = workflowTabId(rec.id, request.requestedAt);
+              try {
+                const result = (await callAction(
+                  "reconcile-workflow-generation" as any,
+                  {
+                    operation: "track",
+                    recordingId: rec.id,
+                    requestedAt: request.requestedAt,
+                    tabId,
+                  } as any,
+                )) as { tracked?: boolean };
+                if (result.tracked !== true) {
+                  fallbackTimer = setTimeout(() => void tick(), 1000);
+                  continue;
+                }
+              } catch {
+                fallbackTimer = setTimeout(() => void tick(), 1000);
+                continue;
+              }
+              const delivery = await sendToAgentChatAndConfirm({
+                ...buildAiRequestChatOptions(rec, request),
+                tabId,
+                chatTarget: "local",
+              });
+              if (!delivery.delivered) {
+                await retryWorkflowAction(
+                  {
+                    operation: "release",
+                    recordingId: rec.id,
+                    requestedAt: request.requestedAt,
+                    tabId,
+                  },
+                  "released",
+                );
+                fallbackTimer = setTimeout(() => void tick(), 1000);
+                continue;
+              }
+              dispatched.current.add(dispatchKey);
+              void persistAndConsumeWorkflowRequest({
+                recordingId: rec.id,
+                requestedAt: request.requestedAt,
+                tabId,
+              });
+              continue;
+            }
+            dispatchAiRequest(rec, request);
+            dispatched.current.add(dispatchKey);
             void clearRequest(rec.id);
           } else if (isAutoTitleReplaceable(rec.title, rec.titleSource)) {
             // No server-queued delegation. Only dispatch the fallback for
@@ -294,8 +388,76 @@ export function buildAiRequestChatOptions(
   };
 }
 
-function dispatchAiRequest(rec: RecordingSummary, request: AiRequest) {
-  sendToAgentChat(buildAiRequestChatOptions(rec, request));
+interface WorkflowRunRequest {
+  recordingId: string;
+  requestedAt: string;
+  tabId: string;
+}
+
+export async function retryWorkflowAction(
+  request: WorkflowRunRequest & { operation: string },
+  successKey: string,
+): Promise<boolean> {
+  for (let attempt = 0; attempt < WORKFLOW_ACTION_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const result = (await callAction(
+        "reconcile-workflow-generation" as any,
+        request as any,
+      )) as Record<string, unknown>;
+      if (result[successKey] === true) return true;
+      if (typeof result.reason === "string" && result.reason !== "stale") {
+        return false;
+      }
+    } catch {}
+
+    if (attempt === WORKFLOW_ACTION_MAX_ATTEMPTS - 1) return false;
+    await new Promise((resolve) =>
+      setTimeout(resolve, WORKFLOW_ACTION_RETRY_DELAY_MS * 2 ** attempt),
+    );
+  }
+
+  return false;
+}
+
+async function consumeWorkflowRequest(
+  request: WorkflowRunRequest,
+): Promise<boolean> {
+  return retryWorkflowAction({ ...request, operation: "consume" }, "consumed");
+}
+
+async function persistAndConsumeWorkflowRequest(
+  request: WorkflowRunRequest,
+): Promise<void> {
+  const delivered = await retryWorkflowAction(
+    { ...request, operation: "mark-delivered" },
+    "delivered",
+  );
+  if (delivered) await consumeWorkflowRequest(request);
+}
+
+function workflowTabId(recordingId: string, requestedAt: string) {
+  return `clips-workflow:${recordingId}:${encodeURIComponent(requestedAt)}:${generateTabId()}`;
+}
+
+function recordingIdFromTab(tabId: string) {
+  const match = /^clips-workflow:([^:]+):/.exec(tabId);
+  return match?.[1];
+}
+
+function requestedAtFromTab(tabId: string) {
+  const match = /^clips-workflow:[^:]+:([^:]+):/.exec(tabId);
+  return match ? decodeURIComponent(match[1]) : undefined;
+}
+
+function dispatchAiRequest(
+  rec: RecordingSummary,
+  request: AiRequest,
+  tabId?: string,
+) {
+  return sendToAgentChat({
+    ...buildAiRequestChatOptions(rec, request),
+    ...(tabId ? { tabId } : {}),
+  });
 }
 
 function parseJsonArray(raw: string | undefined): unknown[] {

package/corpus/templates/clips/app/routes/r.$recordingId.tsx

@@ -27,6 +27,7 @@ import {
   DASHBOARD_REDIRECT_VALUE,
   REF_PARAM,
 } from "@shared/share-attribution";
+import type { WorkflowKind } from "@shared/workflow";
 import {
   IconShare3,
   IconArrowLeft,
@@ -109,7 +110,6 @@ export function meta() {
 }
 
 type SidePanel = "transcript" | "comments" | "insights" | "agent" | "settings";
-type WorkflowKind = "pr" | "sop" | "ticket" | "email";
 
 const WORKFLOW_MENU_ITEMS: Array<{
   kind: WorkflowKind;

package/corpus/templates/clips/changelog/2026-07-27-stopped-agent-runs-no-longer-leave-generated-workflow-cards-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-27
+---
+
+Stopped agent runs no longer leave generated workflow cards spinning indefinitely.

package/corpus/templates/clips/changelog/2026-07-30-workflow-generation-now-stops-retrying-after-repeated-failur.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-30
+---
+
+Workflow generation now stops retrying after repeated failures instead of remaining active indefinitely.

package/corpus/templates/clips/shared/workflow.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const WORKFLOW_KINDS = ["pr", "sop", "ticket", "email"] as const;
+export const WorkflowKindSchema = z.enum(WORKFLOW_KINDS);
+export type WorkflowKind = z.infer<typeof WorkflowKindSchema>;

package/corpus/templates/content/changelog/2026-07-30-long-running-delegated-requests-now-continue-reliably.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-30
+---
+
+Long-running delegated requests now continue reliably.

package/corpus/templates/content/netlify.toml

@@ -10,6 +10,9 @@ GTM_CONTAINER_ID = "GTM-N3WSTXZ"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
 AGENT_RUN_SOFT_TIMEOUT_MS = "55000"
+# Content agent turns can delegate long-running work to sibling apps. Emit and
+# use the async worker so those calls are not cut off by the foreground wall.
+AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
 # A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
 # The framework does not impose a default agent-run timeout; if a template sets

package/corpus/templates/content/server/plugins/agent-chat.ts

@@ -31,6 +31,7 @@ const INITIAL_TOOL_NAMES = [
 
 export default createAgentChatPlugin({
   appId: "content",
+  durableBackgroundRuns: true,
   actions: loadActionsFromStaticRegistry(actionsRegistry),
   initialToolNames: INITIAL_TOOL_NAMES,
   anonymousOwner: resolvePublicViewerOwner,

package/corpus/templates/slides/.agents/skills/create-deck/SKILL.md

@@ -23,7 +23,8 @@ description: How to create a new deck with slides from scratch. Read this before
 When the UI has already created the empty deck, keep its id and rename it before
 adding the first slide. Call `patch-deck` with a `patch-deck-fields` operation
 whose `fields.title` is the generated title. Do not leave the pre-created deck's
-placeholder title in place.
+placeholder title in place. Include only `title` in that operation's `fields`;
+omit all other optional fields.
 
 Follow the creative-context reuse ladder before inventing a slide language:
 reuse an approved native template unchanged, compose approved pieces, lightly

package/corpus/templates/slides/actions/patch-deck.ts

@@ -141,6 +141,27 @@ export const OperationSchema = z.discriminatedUnion("op", [
 
 export type Operation = z.infer<typeof OperationSchema>;
 
+// The browser uses the full operation union above, but the agent only needs
+// this action to rename the empty deck created by the UI. Keeping the
+// advertised schema sparse prevents the model from filling editor-only
+// metadata fields with empty defaults that the runtime correctly rejects.
+const AgentPatchDeckInputSchema = z.object({
+  deckId: z.string().describe("Deck ID"),
+  operations: z
+    .array(
+      z.object({
+        op: z.literal("patch-deck-fields"),
+        fields: z.object({
+          title: z
+            .string()
+            .describe("The concise, specific title to apply to the deck"),
+        }),
+      }),
+    )
+    .min(1)
+    .describe("Rename the pre-created deck before adding its first slide"),
+});
+
 const CreativeContextReuseLabelSchema = z.object({
   itemId: z.string().min(1).optional(),
   itemVersionId: z.string().min(1).optional(),
@@ -323,7 +344,9 @@ export default defineAction({
   description:
     "Granular deck patch used by the browser editor for concurrent-safe writes. " +
     "Each operation touches only the target slide or field — concurrent writers " +
-    "on different slides never overwrite each other's work.",
+    "on different slides never overwrite each other's work. When called by the " +
+    "agent, use it only to set the generated deck title and include no other " +
+    "fields.",
   schema: z.object({
     deckId: z.string().describe("Deck ID"),
     operations: z
@@ -344,6 +367,7 @@ export default defineAction({
         "Optional exact Creative Context provenance for context-backed slide patch operations.",
       ),
   }),
+  agentInputSchema: AgentPatchDeckInputSchema,
   run: async ({ deckId, operations, creativeContext }) => {
     await assertAccess("deck", deckId, "editor");
 

package/corpus/templates/slides/app/components/deck/DeckCard.tsx

@@ -23,6 +23,7 @@ import {
   DropdownMenuSeparator,
 } from "@/components/ui/dropdown-menu";
 import type { Deck } from "@/context/DeckContext";
+import { getAspectRatioDims } from "@/lib/aspect-ratios";
 
 import SlideRenderer from "./SlideRenderer";
 
@@ -51,6 +52,7 @@ export default function DeckCard({
 }: DeckCardProps) {
   const t = useT();
   const firstSlide = deck.slides?.[0];
+  const previewDims = getAspectRatioDims(deck.aspectRatio);
   const [isRenaming, setIsRenaming] = useState(false);
   const [menuOpen, setMenuOpen] = useState(false);
   const [renameValue, setRenameValue] = useState(deck.title);
@@ -104,7 +106,12 @@ export default function DeckCard({
         }}
       >
         {/* Slide Preview */}
-        <div className="overflow-hidden relative">
+        <div
+          className="relative overflow-hidden bg-muted/30"
+          style={{
+            aspectRatio: `${previewDims.width} / ${previewDims.height}`,
+          }}
+        >
           {firstSlide && (
             <SlideRenderer
               slide={firstSlide}
@@ -112,7 +119,7 @@ export default function DeckCard({
               aspectRatio={deck.aspectRatio}
             />
           )}
-          <div className="absolute inset-0 bg-gradient-to-t from-[hsl(240,5%,8%)] via-transparent to-transparent opacity-60" />
+          <div className="pointer-events-none absolute inset-0 bg-gradient-to-t from-[hsl(240,5%,8%)] via-transparent to-transparent opacity-60" />
         </div>
 
         {/* Info */}
@@ -171,7 +178,9 @@ export default function DeckCard({
               onToggleStar(deck.id, !deck.starred);
             }}
             className={`rounded-md border border-border bg-black/60 p-2 backdrop-blur-sm hover:bg-black/80 sm:p-1.5 ${
-              deck.starred ? "" : "sm:opacity-0 sm:group-hover:opacity-100"
+              deck.starred
+                ? ""
+                : "sm:invisible sm:pointer-events-none sm:opacity-0 sm:group-hover:visible sm:group-hover:pointer-events-auto sm:group-hover:opacity-100 sm:group-focus-within:visible sm:group-focus-within:pointer-events-auto sm:group-focus-within:opacity-100"
             }`}
             aria-label={
               deck.starred ? t("home.unstarDeck") : t("home.starDeck")
@@ -192,7 +201,11 @@ export default function DeckCard({
                 e.preventDefault();
                 e.stopPropagation();
               }}
-              className="p-2 sm:p-1.5 rounded-md bg-black/60 backdrop-blur-sm border border-border hover:bg-black/80 sm:opacity-0 sm:group-hover:opacity-100"
+              className={`rounded-md border border-border bg-black/60 p-2 backdrop-blur-sm hover:bg-black/80 sm:p-1.5 ${
+                menuOpen
+                  ? "sm:visible sm:pointer-events-auto sm:opacity-100"
+                  : "sm:invisible sm:pointer-events-none sm:opacity-0 sm:group-hover:visible sm:group-hover:pointer-events-auto sm:group-hover:opacity-100 sm:group-focus-within:visible sm:group-focus-within:pointer-events-auto sm:group-focus-within:opacity-100"
+              }`}
               aria-label={t("raw.deckOptions")}
             >
               <IconDots className="w-3.5 h-3.5 text-foreground/70" />