@agent-native/core 0.188.0 → 0.189.0-nightly-20260925200527

package/corpus/templates/design/server/lib/design-versions.ts

@@ -18,7 +18,7 @@ import {
 import { captureError } from "@agent-native/core/server";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { accessFilter, assertAccess } from "@agent-native/core/sharing";
-import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
+import { and, asc, desc, eq, isNull, like, sql } from "drizzle-orm";
 import { nanoid } from "nanoid";
 
 import {
@@ -49,6 +49,7 @@ export interface DesignVersionChatContext {
   runId?: string;
   turnId?: string;
   actionName?: string;
+  phase?: "start" | "end";
   surface?: "editor";
   /** Which editor-surface caller wrote this checkpoint. Only set alongside
    * `surface: "editor"` — see Throttle 1 below for why it matters. */
@@ -172,6 +173,15 @@ function stableStringify(value: unknown): string {
     .join(",")}}`;
 }
 
+function designVersionIdForIdempotencyKey(
+  designId: string,
+  idempotencyKey: string,
+) {
+  return `design-version-${createHash("sha256")
+    .update(stableStringify({ designId, idempotencyKey }))
+    .digest("hex")}`;
+}
+
 function nextRevisionTimestamp(previous: string | null | undefined): string {
   const previousMs = previous ? Date.parse(previous) : Number.NaN;
   return new Date(
@@ -204,6 +214,9 @@ function parseChatContext(
       context[key] = candidate;
     }
   }
+  if (value.phase === "start" || value.phase === "end") {
+    context.phase = value.phase;
+  }
   if (value.surface === "editor") context.surface = "editor";
   if (value.caller === "frontend" || value.caller === "webmcp") {
     context.caller = value.caller;
@@ -414,7 +427,7 @@ function chatContextKey(
   if (!context || context.surface === "editor") return null;
   const scope = context.threadId ?? "";
   const turn = context.turnId ?? context.runId ?? "";
-  return turn ? `${scope}:${turn}` : null;
+  return turn ? `${scope}:${turn}:${context.phase ?? ""}` : null;
 }
 
 function actionChatContext(
@@ -621,6 +634,7 @@ async function captureDesignVersion(
     chatContext?: DesignVersionChatContext;
     deletionGeometry?: ComponentDeletionGeometry;
     preferStoredFileContent?: boolean;
+    idempotencyKey?: string;
   },
   access: DesignAccess,
   database?: DesignDatabase,
@@ -735,16 +749,18 @@ async function captureDesignVersion(
       };
     }
   }
-  const id = `design-version-${createHash("sha256")
-    .update(
-      stableStringify({
-        designId,
-        previousVersionId: latest?.id ?? "initial",
-        chatContextKey: chatContextKey(options.chatContext),
-        stateHash,
-      }),
-    )
-    .digest("hex")}`;
+  const id = options.idempotencyKey
+    ? designVersionIdForIdempotencyKey(designId, options.idempotencyKey)
+    : `design-version-${createHash("sha256")
+        .update(
+          stableStringify({
+            designId,
+            previousVersionId: latest?.id ?? "initial",
+            chatContextKey: chatContextKey(options.chatContext),
+            stateHash,
+          }),
+        )
+        .digest("hex")}`;
   const snapshot = JSON.stringify({
     schemaVersion: 1,
     snapshotKind: "design-history",
@@ -877,6 +893,41 @@ export async function createDesignVersionSnapshot(
   });
 }
 
+export async function createDesignChatBeginningSnapshot(
+  designId: string,
+  run: { threadId: string; runId: string },
+) {
+  return withDesignVersionLock(designId, async () => {
+    const access = await assertAccess("design", designId, "editor");
+    const rows = await getDb()
+      .select({ id: schema.designVersions.id })
+      .from(schema.designVersions)
+      .where(
+        and(
+          eq(schema.designVersions.designId, designId),
+          eq(
+            schema.designVersions.id,
+            designVersionIdForIdempotencyKey(
+              designId,
+              `chat-start:${run.threadId}`,
+            ),
+          ),
+        ),
+      )
+      .limit(1);
+    if (rows.length) return null;
+    return captureDesignVersion(
+      designId,
+      {
+        label: "Before chat",
+        chatContext: { ...run, phase: "start" },
+        idempotencyKey: `chat-start:${run.threadId}`,
+      },
+      access,
+    );
+  });
+}
+
 function checkpointSkipReason(
   error: unknown,
 ): DesignVersionCheckpointSkipReason {
@@ -1140,6 +1191,7 @@ export async function snapshotDesignBeforeAgentEditInVersionLock(
 export async function listDesignVersions(
   designId: string,
   limit: number,
+  threadId?: string,
 ): Promise<{
   designId: string;
   count: number;
@@ -1147,7 +1199,8 @@ export async function listDesignVersions(
   versions: DesignVersionListEntry[];
 }> {
   await assertAccess("design", designId, "viewer");
-  const rows = await getDb()
+  const db = getDb();
+  const rows = await db
     .select({
       id: schema.designVersions.id,
       label: schema.designVersions.label,
@@ -1163,11 +1216,46 @@ export async function listDesignVersions(
       desc(schema.designVersions.id),
     )
     .limit(limit);
+  const beginningRows = await db
+    .select({
+      id: schema.designVersions.id,
+      label: schema.designVersions.label,
+      createdAt: schema.designVersions.createdAt,
+      chatContext: schema.designVersions.chatContext,
+      fileCount: schema.designVersions.fileCount,
+    })
+    .from(schema.designVersions)
+    .where(
+      threadId
+        ? and(
+            eq(schema.designVersions.designId, designId),
+            eq(
+              schema.designVersions.id,
+              designVersionIdForIdempotencyKey(
+                designId,
+                `chat-start:${threadId}`,
+              ),
+            ),
+          )
+        : and(
+            eq(schema.designVersions.designId, designId),
+            like(schema.designVersions.chatContext, '%"phase":"start"%'),
+          ),
+    )
+    .orderBy(
+      asc(isNull(schema.designVersions.createdAt)),
+      asc(schema.designVersions.createdAt),
+    )
+    .limit(threadId ? 1 : limit);
+  const rowsById = new Map(
+    [...rows, ...beginningRows].map((row) => [row.id, row]),
+  );
 
   const regular: DesignVersionListEntry[] = [];
   const chat = new Map<string, DesignVersionListEntry>();
+  const activeStartEntries: DesignVersionListEntry[] = [];
   let invalidCount = 0;
-  for (const row of rows) {
+  for (const row of rowsById.values()) {
     let chatContext: DesignVersionChatContext | undefined;
     try {
       chatContext = parseStoredChatContext(row.chatContext);
@@ -1195,19 +1283,47 @@ export async function listDesignVersions(
       regular.push(entry);
       continue;
     }
-    const previous = chat.get(key);
     if (
-      !previous ||
-      versionTime(entry.createdAt) < versionTime(previous.createdAt)
+      threadId &&
+      chatContext?.threadId === threadId &&
+      chatContext.phase === "start"
     ) {
-      chat.set(key, entry);
+      activeStartEntries.push(entry);
+      continue;
     }
+    const previous = chat.get(key);
+    const replacePrevious =
+      !previous ||
+      (chatContext?.phase === "end"
+        ? versionTime(entry.createdAt) > versionTime(previous.createdAt)
+        : versionTime(entry.createdAt) < versionTime(previous.createdAt));
+    if (replacePrevious) chat.set(key, entry);
   }
 
-  const versions = [...regular, ...chat.values()].sort(
+  const versions = [...regular, ...chat.values(), ...activeStartEntries].sort(
     (left, right) => versionTime(right.createdAt) - versionTime(left.createdAt),
   );
-  return { designId, count: versions.length, invalidCount, versions };
+  const limitedVersions = versions.slice(0, limit);
+  const activeStart = threadId
+    ? versions.find(
+        (version) =>
+          version.chatContext?.threadId === threadId &&
+          version.chatContext.phase === "start",
+      )
+    : undefined;
+  if (activeStart && !limitedVersions.includes(activeStart)) {
+    limitedVersions[limitedVersions.length - 1] = activeStart;
+    limitedVersions.sort(
+      (left, right) =>
+        versionTime(right.createdAt) - versionTime(left.createdAt),
+    );
+  }
+  return {
+    designId,
+    count: limitedVersions.length,
+    invalidCount,
+    versions: limitedVersions,
+  };
 }
 
 interface RestoreFile {

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

@@ -232,21 +232,37 @@ async function autosaveDesignAfterAgentTurn(
   },
 ): Promise<void> {
   if (scope.type !== "design" || !(await hasDesignEdit(run, scope.id))) return;
+  if (!run.threadId || !run.runId) return;
 
   const { createDesignVersionSnapshot } =
     await import("../lib/design-versions.js");
   await createDesignVersionSnapshot(scope.id, {
     label: "Chat autosave",
     chatContext: {
-      ...(run.threadId ? { threadId: run.threadId } : {}),
-      ...(run.runId ? { runId: run.runId } : {}),
+      threadId: run.threadId,
+      runId: run.runId,
       ...(run.turnId ? { turnId: run.turnId } : {}),
+      phase: "end",
     },
   });
 }
 
+async function autosaveDesignBeforeAgentTurn(
+  scope: { type: string; id: string },
+  run: { threadId?: string; runId?: string },
+): Promise<void> {
+  if (scope.type !== "design" || !run.threadId || !run.runId) return;
+  const { createDesignChatBeginningSnapshot } =
+    await import("../lib/design-versions.js");
+  await createDesignChatBeginningSnapshot(scope.id, {
+    threadId: run.threadId,
+    runId: run.runId,
+  });
+}
+
 export default createAgentChatPlugin({
   appId: "design",
+  onAgentTurnStart: autosaveDesignBeforeAgentTurn,
   onAgentTurnComplete: autosaveDesignAfterAgentTurn,
   actions: guardRepromptActionRegistry(
     loadActionsFromStaticRegistry(actionsRegistry),

package/corpus/templates/slides/actions/list-deck-versions.ts

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core/action";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, desc, eq } from "drizzle-orm";
+import { and, asc, desc, eq, like } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -50,13 +50,18 @@ export default defineAction({
   schema: z.object({
     deckId: z.string().describe("Deck ID"),
     limit: z.coerce.number().int().min(1).max(100).default(50),
+    threadId: z.string().min(1).optional(),
   }),
   http: { method: "GET" },
-  run: async ({ deckId, limit }) => {
+  run: async ({ deckId, limit, threadId }) => {
     const access = await assertAccess("deck", deckId, "viewer");
     const ownerEmail = access.resource.ownerEmail as string;
     const db = getDb();
 
+    const where = and(
+      eq(schema.deckVersions.deckId, deckId),
+      eq(schema.deckVersions.ownerEmail, ownerEmail),
+    );
     const versions = await db
       .select({
         id: schema.deckVersions.id,
@@ -68,19 +73,66 @@ export default defineAction({
         createdAt: schema.deckVersions.createdAt,
       })
       .from(schema.deckVersions)
-      .where(
-        and(
-          eq(schema.deckVersions.deckId, deckId),
-          eq(schema.deckVersions.ownerEmail, ownerEmail),
-        ),
-      )
+      .where(where)
       .orderBy(desc(schema.deckVersions.createdAt))
       .limit(limit);
+    const beginningVersions = await db
+      .select({
+        id: schema.deckVersions.id,
+        deckId: schema.deckVersions.deckId,
+        title: schema.deckVersions.title,
+        data: schema.deckVersions.data,
+        changeLabel: schema.deckVersions.changeLabel,
+        chatContext: schema.deckVersions.chatContext,
+        createdAt: schema.deckVersions.createdAt,
+      })
+      .from(schema.deckVersions)
+      .where(
+        threadId
+          ? and(
+              where,
+              eq(schema.deckVersions.changeGroup, `start:thread:${threadId}`),
+            )
+          : and(
+              where,
+              like(schema.deckVersions.chatContext, '%"phase":"start"%'),
+            ),
+      )
+      .orderBy(
+        threadId
+          ? asc(schema.deckVersions.createdAt)
+          : desc(schema.deckVersions.createdAt),
+      )
+      .limit(threadId ? 1 : limit);
+    const versionsById = new Map(
+      [...beginningVersions, ...versions].map((version) => [
+        version.id,
+        version,
+      ]),
+    );
+    const allVersions = [...versionsById.values()];
+    allVersions.sort(
+      (left, right) =>
+        new Date(right.createdAt).getTime() -
+        new Date(left.createdAt).getTime(),
+    );
+    const limitedVersions = allVersions.slice(0, limit);
+    const activeStart = threadId
+      ? allVersions.find((version) => beginningVersions.includes(version))
+      : undefined;
+    if (activeStart && !limitedVersions.includes(activeStart)) {
+      limitedVersions[limitedVersions.length - 1] = activeStart;
+      limitedVersions.sort(
+        (left, right) =>
+          new Date(right.createdAt).getTime() -
+          new Date(left.createdAt).getTime(),
+      );
+    }
 
     return {
       deckId,
-      count: versions.length,
-      versions: versions.map((version) => {
+      count: limitedVersions.length,
+      versions: limitedVersions.map((version) => {
         let chatContext;
         try {
           chatContext = parseDeckVersionChatContext(version.chatContext);

package/corpus/templates/slides/app/components/layout/Layout.tsx

@@ -21,6 +21,7 @@ import { IconMenu2 } from "@tabler/icons-react";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { useLocation, useNavigate } from "react-router";
 
+import { useDecks } from "@/context/DeckContext";
 import { useSidebarCollapsed } from "@/hooks/use-sidebar-collapsed";
 import {
   buildSlidesAgentContext,
@@ -67,6 +68,7 @@ export function Layout({ children }: LayoutProps) {
   const location = useLocation();
   const navigate = useNavigate();
   const t = useT();
+  const { flushDeckSave } = useDecks();
   const creativeContextEnabled = useCreativeContextLab();
   const isChatRoute =
     location.pathname === "/chat" || location.pathname.startsWith("/chat/");
@@ -155,9 +157,14 @@ export function Layout({ children }: LayoutProps) {
     if (!deckScope) return undefined;
     const deckId = deckScope.id;
     return {
+      beforeStart: () => flushDeckSave(deckId),
       list: {
         action: "list-deck-versions",
-        args: { deckId, limit: 100 },
+        args: (threadId) => ({
+          deckId,
+          limit: 100,
+          ...(threadId ? { threadId } : {}),
+        }),
         getVersions: (result: unknown) => {
           const versions =
             result && typeof result === "object"
@@ -174,9 +181,10 @@ export function Layout({ children }: LayoutProps) {
           deckId,
           versionId: version.id,
         }),
+        beforeRestore: () => flushDeckSave(deckId),
       },
     };
-  }, [deckScope]);
+  }, [deckScope, flushDeckSave]);
 
   useAgentChatHomeHandoffLinks({
     storageKey: "slides",

package/corpus/templates/slides/changelog/2026-09-25-chat-messages-can-be-reverted-to-their-autosaved-version-inc.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-09-25
+---
+
+Chat messages can be reverted to their autosaved version, including a shortcut to restore the start of a chat.

package/corpus/templates/slides/server/lib/deck-versions.ts

@@ -13,12 +13,14 @@ export interface DeckVersionChatContext {
   threadId?: string;
   runId?: string;
   turnId?: string;
+  phase?: "start" | "end";
 }
 
 function contextFromFields(value: {
   threadId?: unknown;
   runId?: unknown;
   turnId?: unknown;
+  phase?: unknown;
 }): DeckVersionChatContext | undefined {
   const context: DeckVersionChatContext = {};
   for (const key of ["threadId", "runId", "turnId"] as const) {
@@ -26,6 +28,9 @@ function contextFromFields(value: {
       context[key] = value[key];
     }
   }
+  if (value.phase === "start" || value.phase === "end") {
+    context.phase = value.phase;
+  }
   return Object.keys(context).length > 0 ? context : undefined;
 }
 
@@ -139,6 +144,7 @@ export async function createDeckVersionSnapshot(
     .limit(1);
 
   if (
+    options.chatContext?.phase !== "start" &&
     latestVersion &&
     latestVersion.title === source.title &&
     deckContentSignature(latestVersion.data) ===
@@ -150,8 +156,12 @@ export async function createDeckVersionSnapshot(
   const requestedChatContext = serializeDeckVersionChatContext(
     options.chatContext,
   );
-  const changeGroup =
+  const turnGroup =
     options.chatContext?.turnId ?? options.chatContext?.runId ?? undefined;
+  const changeGroup =
+    options.chatContext?.phase === "start" && turnGroup
+      ? `start:thread:${options.chatContext.threadId ?? turnGroup}`
+      : turnGroup;
   if (
     requestedChatContext &&
     requestedChatContext === normalizedChatContext(latestVersion?.chatContext)
@@ -196,3 +206,28 @@ export async function createDeckVersionSnapshot(
 
   return { created: true, id };
 }
+
+export async function createDeckChatBeginningSnapshot(
+  source: DeckSnapshotSource,
+  run: { threadId: string; runId: string },
+): Promise<{ created: boolean; id?: string; reason?: string }> {
+  const rows = await getDb()
+    .select({ id: schema.deckVersions.id })
+    .from(schema.deckVersions)
+    .where(
+      and(
+        eq(schema.deckVersions.deckId, source.id),
+        eq(schema.deckVersions.ownerEmail, source.ownerEmail),
+        eq(schema.deckVersions.changeGroup, `start:thread:${run.threadId}`),
+      ),
+    )
+    .limit(1);
+  if (rows.length) {
+    return { created: false, reason: "beginning-exists" };
+  }
+  return createDeckVersionSnapshot(source, {
+    force: true,
+    label: "Before chat",
+    chatContext: { ...run, phase: "start" },
+  });
+}

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

@@ -7,7 +7,10 @@ import { assertAccess } from "@agent-native/core/sharing";
 import actionsRegistry from "../../.generated/actions-registry.js";
 import { resolveSlidesRequestAuthContext } from "../handlers/request-auth-context.js";
 import { prepareSlidesChatAttachments } from "../lib/chat-attachments.js";
-import { deckVersionChatContextFromRun } from "../lib/deck-versions.js";
+import {
+  createDeckChatBeginningSnapshot,
+  deckVersionChatContextFromRun,
+} from "../lib/deck-versions.js";
 import "../register-secrets.js";
 
 const SLIDES_BACKGROUND_RUN_SOFT_TIMEOUT_MS = 13 * 60_000;
@@ -138,6 +141,7 @@ async function autosaveDeckAfterAgentTurn(
   },
 ): Promise<void> {
   if (scope.type !== "deck" || !hasDeckEdit(run, scope.id)) return;
+  if (!run.threadId || !run.runId) return;
 
   const access = await assertAccess("deck", scope.id, "editor");
   const deck = access.resource as {
@@ -147,15 +151,35 @@ async function autosaveDeckAfterAgentTurn(
     ownerEmail: string;
   };
   const { createDeckVersionSnapshot } = await import("../lib/deck-versions.js");
+  const chatContext = deckVersionChatContextFromRun(run);
   await createDeckVersionSnapshot(deck, {
     force: true,
     label: "Chat autosave",
-    chatContext: deckVersionChatContextFromRun(run),
+    chatContext: chatContext ? { ...chatContext, phase: "end" } : undefined,
+  });
+}
+
+async function autosaveDeckBeforeAgentTurn(
+  scope: { type: string; id: string },
+  run: { threadId?: string; runId?: string },
+): Promise<void> {
+  if (scope.type !== "deck" || !run.threadId || !run.runId) return;
+  const access = await assertAccess("deck", scope.id, "editor");
+  const deck = access.resource as {
+    id: string;
+    title: string;
+    data: string;
+    ownerEmail: string;
+  };
+  await createDeckChatBeginningSnapshot(deck, {
+    threadId: run.threadId,
+    runId: run.runId,
   });
 }
 
 export default createAgentChatPlugin({
   appId: "slides",
+  onAgentTurnStart: autosaveDeckBeforeAgentTurn,
   onAgentTurnComplete: autosaveDeckAfterAgentTurn,
   actions: loadActionsFromStaticRegistry(actionsRegistry),
   initialToolNames: INITIAL_TOOL_NAMES,

package/dist/automation/index.d.ts

@@ -186,8 +186,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;