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

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 9959
+- template files: 9962

package/corpus/templates/content/actions/list-document-versions.ts

@@ -1,9 +1,10 @@
 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";
+import { documentChatStartVersionId } from "../server/lib/document-history.js";
 import { parseDocumentVersionChatContext } from "../server/lib/document-version-context.js";
 
 export default defineAction({
@@ -16,6 +17,7 @@ export default defineAction({
       .default(true)
       .describe("Include full version content in the response"),
     limit: z.coerce.number().int().min(1).max(100).default(100),
+    threadId: z.string().min(1).optional(),
   }),
   http: { method: "GET" },
   readOnly: true,
@@ -48,9 +50,107 @@ export default defineAction({
           .where(where)
           .orderBy(desc(schema.documentVersions.createdAt))
           .limit(args.limit);
+    const beginningVersions = args.threadId
+      ? args.includeContent
+        ? await db
+            .select()
+            .from(schema.documentVersions)
+            .where(
+              and(
+                where,
+                eq(
+                  schema.documentVersions.id,
+                  documentChatStartVersionId(
+                    ownerEmail,
+                    args.documentId,
+                    args.threadId,
+                  ),
+                ),
+              ),
+            )
+            .orderBy(asc(schema.documentVersions.createdAt))
+            .limit(1)
+        : await db
+            .select({
+              id: schema.documentVersions.id,
+              documentId: schema.documentVersions.documentId,
+              title: schema.documentVersions.title,
+              createdAt: schema.documentVersions.createdAt,
+              chatContext: schema.documentVersions.chatContext,
+            })
+            .from(schema.documentVersions)
+            .where(
+              and(
+                where,
+                eq(
+                  schema.documentVersions.id,
+                  documentChatStartVersionId(
+                    ownerEmail,
+                    args.documentId,
+                    args.threadId,
+                  ),
+                ),
+              ),
+            )
+            .orderBy(asc(schema.documentVersions.createdAt))
+            .limit(1)
+      : args.includeContent
+        ? await db
+            .select()
+            .from(schema.documentVersions)
+            .where(
+              and(
+                where,
+                like(schema.documentVersions.chatContext, '%"phase":"start"%'),
+              ),
+            )
+            .orderBy(desc(schema.documentVersions.createdAt))
+            .limit(args.limit)
+        : await db
+            .select({
+              id: schema.documentVersions.id,
+              documentId: schema.documentVersions.documentId,
+              title: schema.documentVersions.title,
+              createdAt: schema.documentVersions.createdAt,
+              chatContext: schema.documentVersions.chatContext,
+            })
+            .from(schema.documentVersions)
+            .where(
+              and(
+                where,
+                like(schema.documentVersions.chatContext, '%"phase":"start"%'),
+              ),
+            )
+            .orderBy(desc(schema.documentVersions.createdAt))
+            .limit(args.limit);
+    const versionsById = new Map(
+      [...beginningVersions, ...versions].map((version) => [
+        version.id,
+        version,
+      ]),
+    );
+
+    const mergedVersions = [...versionsById.values()];
+    const sortedVersions = mergedVersions.sort(
+      (left, right) =>
+        new Date(right.createdAt).getTime() -
+        new Date(left.createdAt).getTime(),
+    );
+    const limitedVersions = sortedVersions.slice(0, args.limit);
+    const activeStart = args.threadId
+      ? sortedVersions.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 {
-      versions: versions.map((version) => {
+      versions: limitedVersions.map((version) => {
         let chatContext;
         try {
           chatContext = parseDocumentVersionChatContext(version.chatContext);

package/corpus/templates/content/actions/restore-document-version.ts

@@ -23,6 +23,7 @@ import {
   documentContentHash,
   documentRevisionToken,
 } from "./_document-edit-mutation.js";
+import { flushOpenDocumentEditorToSql } from "./_document-flush.js";
 
 function isLinkedLocalSource(
   documentId: string,
@@ -78,6 +79,53 @@ export default defineAction({
     if (isLinkedLocalSource(documentId, source))
       linkedLocalRestoreUnsupported();
     const db = getDb();
+    const [beforeFlush] = await db
+      .select({ updatedAt: schema.documents.updatedAt })
+      .from(schema.documents)
+      .where(
+        and(
+          eq(schema.documents.id, documentId),
+          eq(schema.documents.ownerEmail, ownerEmail),
+        ),
+      )
+      .limit(1);
+    if (!beforeFlush) {
+      throw new ActionContractError("Document not found.", {
+        errorCode: "DOCUMENT_NOT_FOUND",
+        statusCode: 404,
+      });
+    }
+    if (beforeFlush.updatedAt !== args.expectedUpdatedAt) {
+      throw new ActionContractError(
+        "The document changed after this restore was prepared.",
+        {
+          errorCode: "DOCUMENT_RESTORE_CONFLICT",
+          statusCode: 409,
+          details: {
+            expectedUpdatedAt: args.expectedUpdatedAt,
+            currentUpdatedAt: beforeFlush.updatedAt,
+          },
+        },
+      );
+    }
+    await flushOpenDocumentEditorToSql({ documentId, ownerEmail });
+    const [afterFlush] = await db
+      .select({ updatedAt: schema.documents.updatedAt })
+      .from(schema.documents)
+      .where(
+        and(
+          eq(schema.documents.id, documentId),
+          eq(schema.documents.ownerEmail, ownerEmail),
+        ),
+      )
+      .limit(1);
+    if (!afterFlush) {
+      throw new ActionContractError("Document not found.", {
+        errorCode: "DOCUMENT_NOT_FOUND",
+        statusCode: 404,
+      });
+    }
+    const expectedUpdatedAt = afterFlush.updatedAt;
     let softDeletedDatabaseIds: string[] = [];
     const updated = await db.transaction(async (rawTx) => {
       const tx = rawTx as any;
@@ -110,14 +158,14 @@ export default defineAction({
       if (isLinkedLocalSource(documentId, current)) {
         linkedLocalRestoreUnsupported();
       }
-      if (current.updatedAt !== args.expectedUpdatedAt) {
+      if (current.updatedAt !== expectedUpdatedAt) {
         throw new ActionContractError(
           "The document changed after this restore was prepared.",
           {
             errorCode: "DOCUMENT_RESTORE_CONFLICT",
             statusCode: 409,
             details: {
-              expectedUpdatedAt: args.expectedUpdatedAt,
+              expectedUpdatedAt,
               currentUpdatedAt: current.updatedAt,
             },
           },

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

@@ -126,7 +126,12 @@ export function Layout({ children }: LayoutProps) {
     return {
       list: {
         action: "list-document-versions",
-        args: { documentId, includeContent: false, limit: 100 },
+        args: (threadId) => ({
+          documentId,
+          includeContent: false,
+          limit: 100,
+          ...(threadId ? { threadId } : {}),
+        }),
         getVersions: (result: unknown) => {
           const versions =
             result && typeof result === "object"

package/corpus/templates/content/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/content/server/lib/document-history.ts

@@ -8,6 +8,7 @@ import type {
 import { getDb, schema } from "../db/index.js";
 import {
   documentVersionChatContextFromAction,
+  type DocumentVersionChatContext,
   serializeDocumentVersionChatContext,
 } from "./document-version-context.js";
 
@@ -26,6 +27,8 @@ export interface DocumentHistoryCause {
   actorEmail?: string | null;
   actorKind?: Exclude<DocumentHistoryActorKind, "unknown">;
   origin?: string;
+  chatContext?: DocumentVersionChatContext;
+  skipBeforeCheckpoint?: boolean;
   operation: string;
 }
 
@@ -42,6 +45,14 @@ function newGroupId(prefix: string) {
   return `${prefix}:${crypto.randomUUID()}`;
 }
 
+export function documentChatStartVersionId(
+  ownerEmail: string,
+  documentId: string,
+  chatStartKey: string,
+) {
+  return `agent-chat-start:${encodeURIComponent(ownerEmail)}:${encodeURIComponent(documentId)}:${encodeURIComponent(chatStartKey)}`;
+}
+
 export function resolveDocumentHistoryCause(
   cause: DocumentHistoryCause,
 ): ResolvedDocumentHistoryCause {
@@ -152,9 +163,10 @@ export async function recordDocumentHistoryTransition(args: {
 
   let beforeCheckpointId: string | undefined;
   if (
-    !latest ||
-    latest.title !== args.before.title ||
-    latest.content !== args.before.content
+    !args.cause.skipBeforeCheckpoint &&
+    (!latest ||
+      latest.title !== args.before.title ||
+      latest.content !== args.before.content)
   ) {
     beforeCheckpointId = crypto.randomUUID();
     await args.db.insert(schema.documentVersions).values({
@@ -164,7 +176,8 @@ export async function recordDocumentHistoryTransition(args: {
       title: args.before.title,
       content: args.before.content,
       chatContext: serializeDocumentVersionChatContext(
-        documentVersionChatContextFromAction(args.cause.ctx),
+        args.cause.chatContext ??
+          documentVersionChatContextFromAction(args.cause.ctx),
       ),
       ...cause,
       checkpointKind: "before",
@@ -176,20 +189,58 @@ export async function recordDocumentHistoryTransition(args: {
   const afterCreatedAt = beforeCheckpointId
     ? new Date(new Date(checkpointCreatedAt).getTime() + 1).toISOString()
     : checkpointCreatedAt;
-  const afterCheckpointId = crypto.randomUUID();
-  await args.db.insert(schema.documentVersions).values({
+  const isChatStart =
+    cause.groupKind === "agent_run" && cause.operation === "chat start";
+  const chatStartKey = args.cause.chatContext?.threadId ?? cause.groupId;
+  const afterCheckpointId = isChatStart
+    ? documentChatStartVersionId(args.ownerEmail, args.documentId, chatStartKey)
+    : crypto.randomUUID();
+  const afterValues = {
     id: afterCheckpointId,
     ownerEmail: args.ownerEmail,
     documentId: args.documentId,
     title: args.after.title,
     content: args.after.content,
     chatContext: serializeDocumentVersionChatContext(
-      documentVersionChatContextFromAction(args.cause.ctx),
+      args.cause.chatContext ??
+        documentVersionChatContextFromAction(args.cause.ctx),
     ),
     ...cause,
     checkpointKind: "after",
     createdAt: afterCreatedAt,
     updatedAt: afterCreatedAt,
-  });
+  };
+  if (isChatStart) {
+    const [inserted] = await args.db
+      .insert(schema.documentVersions)
+      .values(afterValues)
+      .onConflictDoNothing()
+      .returning({ id: schema.documentVersions.id });
+    if (!inserted) {
+      const [existing] = await args.db
+        .select({ id: schema.documentVersions.id })
+        .from(schema.documentVersions)
+        .where(
+          and(
+            eq(schema.documentVersions.ownerEmail, args.ownerEmail),
+            eq(schema.documentVersions.documentId, args.documentId),
+            eq(schema.documentVersions.id, afterCheckpointId),
+          ),
+        )
+        .limit(1);
+      if (!existing) {
+        throw new Error(
+          "Chat-start history checkpoint conflict had no matching checkpoint.",
+        );
+      }
+      return {
+        groupId: cause.groupId,
+        beforeCheckpointId,
+        afterCheckpointId: existing.id,
+      };
+    }
+  } else {
+    await args.db.insert(schema.documentVersions).values(afterValues);
+  }
   return { groupId: cause.groupId, beforeCheckpointId, afterCheckpointId };
 }

package/corpus/templates/content/server/lib/document-version-context.ts

@@ -4,12 +4,14 @@ export interface DocumentVersionChatContext {
   threadId?: string;
   runId?: string;
   turnId?: string;
+  phase?: "start" | "end";
 }
 
 function contextFromFields(value: {
   threadId?: unknown;
   runId?: unknown;
   turnId?: unknown;
+  phase?: unknown;
 }): DocumentVersionChatContext | undefined {
   const context: DocumentVersionChatContext = {};
   for (const key of ["threadId", "runId", "turnId"] as const) {
@@ -17,6 +19,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;
 }
 

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

@@ -3,9 +3,17 @@ import {
   createAgentChatPlugin,
   loadActionsFromStaticRegistry,
 } from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
 
 import actionsRegistry from "../../.generated/actions-registry.js";
+import { flushOpenDocumentEditorToSql } from "../../actions/_document-flush.js";
+import { getDb, schema } from "../db/index.js";
 import { resolveCommentAiActionSurface } from "../lib/comment-ai.js";
+import {
+  documentChatStartVersionId,
+  recordDocumentHistoryTransition,
+} from "../lib/document-history.js";
 import {
   publicDocumentExtraContext,
   resolvePublicViewerOwner,
@@ -21,8 +29,164 @@ const INJECTED_INITIAL_TOOL_NAMES = [
   "query-staged-dataset",
 ];
 
+const DOCUMENT_EDIT_TOOLS = new Set([
+  "edit-document",
+  "restore-document-version",
+  "update-document",
+]);
+
+function eventRecord(entry: unknown): Record<string, unknown> | undefined {
+  if (!entry || typeof entry !== "object") return undefined;
+  const event = (entry as { event?: unknown }).event;
+  return event && typeof event === "object"
+    ? (event as Record<string, unknown>)
+    : undefined;
+}
+
+function inputForCompletedTool(
+  events: readonly unknown[],
+  index: number,
+  completed: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+  if (completed.input && typeof completed.input === "object") {
+    return completed.input as Record<string, unknown>;
+  }
+  const id = typeof completed.id === "string" ? completed.id : undefined;
+  for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+    const candidate = eventRecord(events[cursor]);
+    if (
+      candidate?.type !== "tool_start" ||
+      candidate.tool !== completed.tool ||
+      (id && candidate.id !== id)
+    ) {
+      continue;
+    }
+    return candidate.input && typeof candidate.input === "object"
+      ? (candidate.input as Record<string, unknown>)
+      : undefined;
+  }
+  return undefined;
+}
+
+function hasDocumentEdit(
+  run: { events: readonly unknown[] },
+  documentId: string,
+): boolean {
+  return run.events.some((entry, index) => {
+    const record = eventRecord(entry);
+    if (
+      record?.type !== "tool_done" ||
+      record.completedSideEffect !== true ||
+      record.isError === true ||
+      typeof record.tool !== "string" ||
+      !DOCUMENT_EDIT_TOOLS.has(record.tool)
+    ) {
+      return false;
+    }
+    const input = inputForCompletedTool(run.events, index, record);
+    return (input?.documentId ?? input?.id) === documentId;
+  });
+}
+
+async function autosaveDocumentAtChatBoundary(
+  scope: { type: string; id: string },
+  run: { events?: readonly unknown[]; threadId?: string; runId?: string },
+  phase: "start" | "end",
+): Promise<void> {
+  const hasEdit = run.events
+    ? hasDocumentEdit({ events: run.events }, scope.id)
+    : false;
+  if (
+    scope.type !== "document" ||
+    !run.threadId ||
+    !run.runId ||
+    (phase === "end" && !hasEdit)
+  ) {
+    return;
+  }
+
+  let access = await assertAccess("document", scope.id, "editor");
+  let document = access.resource as {
+    ownerEmail: string;
+    title: string;
+    content: string;
+  };
+  if (phase === "start") {
+    await flushOpenDocumentEditorToSql({
+      documentId: scope.id,
+      ownerEmail: document.ownerEmail,
+    });
+    access = await assertAccess("document", scope.id, "editor");
+    document = access.resource as typeof document;
+  }
+  const db = getDb();
+  const chatContext = { threadId: run.threadId, runId: run.runId, phase };
+
+  if (phase === "start") {
+    const existing = await db
+      .select({ id: schema.documentVersions.id })
+      .from(schema.documentVersions)
+      .where(
+        and(
+          eq(schema.documentVersions.documentId, scope.id),
+          eq(schema.documentVersions.ownerEmail, document.ownerEmail),
+          eq(
+            schema.documentVersions.id,
+            documentChatStartVersionId(
+              document.ownerEmail,
+              scope.id,
+              run.threadId,
+            ),
+          ),
+        ),
+      )
+      .limit(1);
+    if (existing.length) return;
+  }
+
+  const state = { title: document.title, content: document.content };
+  await recordDocumentHistoryTransition({
+    db,
+    ownerEmail: document.ownerEmail,
+    documentId: scope.id,
+    before: state,
+    after: state,
+    cause: {
+      groupId: `agent:${document.ownerEmail}:${run.runId}`,
+      groupKind: "agent_run",
+      actorEmail: document.ownerEmail,
+      actorKind: "agent",
+      origin: "agent-chat",
+      operation: phase === "start" ? "chat start" : "chat autosave",
+      chatContext,
+      ...(phase === "start" ? { skipBeforeCheckpoint: true } : {}),
+    },
+    now: new Date().toISOString(),
+  });
+}
+
+async function autosaveDocumentBeforeAgentTurn(
+  scope: { type: string; id: string },
+  run: { threadId?: string; runId?: string },
+): Promise<void> {
+  await autosaveDocumentAtChatBoundary(scope, run, "start");
+}
+
+async function autosaveDocumentAfterAgentTurn(
+  scope: { type: string; id: string },
+  run: {
+    events: readonly unknown[];
+    threadId?: string;
+    runId?: string;
+  },
+): Promise<void> {
+  await autosaveDocumentAtChatBoundary(scope, run, "end");
+}
+
 export default createAgentChatPlugin({
   appId: "content",
+  onAgentTurnStart: autosaveDocumentBeforeAgentTurn,
+  onAgentTurnComplete: autosaveDocumentAfterAgentTurn,
   nativeActionsInDev: true,
   resolveActionSurface: resolveCommentAiActionSurface,
   durableBackgroundRuns: true,

package/corpus/templates/design/actions/list-design-versions.ts

@@ -9,6 +9,7 @@ export default defineAction({
     "metadata only, not the stored file contents.",
   schema: z.object({
     designId: z.string().describe("Design project ID"),
+    threadId: z.string().min(1).optional(),
     limit: z.coerce
       .number()
       .int()
@@ -19,5 +20,6 @@ export default defineAction({
   }),
   http: { method: "GET" },
   readOnly: true,
-  run: async ({ designId, limit }) => listDesignVersions(designId, limit),
+  run: async ({ designId, limit, threadId }) =>
+    listDesignVersions(designId, limit, threadId),
 });

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

@@ -129,15 +129,29 @@ export function Layout({ children }: LayoutProps) {
     if (!designId) return null;
     return { type: "design" as const, id: designId };
   }, [location.pathname]);
+  const flushDesignEditorSaves = useCallback(async () => {
+    const flushes: Promise<void>[] = [];
+    window.dispatchEvent(
+      new CustomEvent("agent-native:design-flush-pending-saves", {
+        detail: flushes,
+      }),
+    );
+    await Promise.all(flushes);
+  }, []);
   const designChatHistory = useMemo<
     AssistantChatHistoryConfig | undefined
   >(() => {
     if (!designScope) return undefined;
     const designId = designScope.id;
     return {
+      beforeStart: flushDesignEditorSaves,
       list: {
         action: "list-design-versions",
-        args: { designId, limit: 100 },
+        args: (threadId) => ({
+          designId,
+          limit: 100,
+          ...(threadId ? { threadId } : {}),
+        }),
         getVersions: (result: unknown) => {
           const versions =
             result && typeof result === "object"
@@ -154,9 +168,10 @@ export function Layout({ children }: LayoutProps) {
           designId,
           versionId: version.id,
         }),
+        beforeRestore: flushDesignEditorSaves,
       },
     };
-  }, [designScope]);
+  }, [designScope, flushDesignEditorSaves]);
   const chatHomeHandoffActive = useAgentChatHomeHandoff({
     storageKey: DESIGN_CHAT_STORAGE_KEY,
     activePath: location.pathname,

package/corpus/templates/design/app/pages/design-editor/editor-state.ts

@@ -741,9 +741,9 @@ export function flushFileContentSavesOnBackground(
   pendingByFileId: FileContentSaveRequestsById,
   latestUnacknowledgedByFileId: FileContentSaveRequestsById,
   timerIds: readonly number[],
-  save: (pending: FileContentSaveRequest) => void,
+  save: (pending: FileContentSaveRequest) => unknown | Promise<unknown>,
   clearTimer: (timerId: number) => void,
-): void {
+): Promise<void> {
   const newestByFileId = new Map<string, FileContentSaveRequest>();
   for (const pending of Object.values(latestUnacknowledgedByFileId)) {
     newestByFileId.set(pending.id, pending);
@@ -754,8 +754,15 @@ export function flushFileContentSavesOnBackground(
       newestByFileId.set(pending.id, pending);
     }
   }
-  for (const pending of newestByFileId.values()) save(pending);
+  const saves = [...newestByFileId.values()].map((pending) => {
+    try {
+      return Promise.resolve(save(pending));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  });
   for (const timerId of timerIds) clearTimer(timerId);
+  return Promise.all(saves).then(() => undefined);
 }
 
 /**

package/corpus/templates/design/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.