@agent-native/core 0.83.0 → 0.84.1

package/corpus/templates/calendar/actions/connect-google-calendar.ts

@@ -0,0 +1,80 @@
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server";
+import { z } from "zod";
+
+const CONNECT_PATH = "/_agent-native/google/auth-url";
+const ADD_ACCOUNT_PATH = "/_agent-native/google/add-account/auth-url";
+
+function normalizeReturnPath(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  try {
+    const url = new URL(value, "https://calendar.agent-native.local");
+    if (url.origin !== "https://calendar.agent-native.local") {
+      return undefined;
+    }
+    return `${url.pathname}${url.search}${url.hash}`;
+  } catch {
+    return undefined;
+  }
+}
+
+export default defineAction({
+  description:
+    "Create a user-clickable Google Calendar OAuth link. Use this when the user asks to connect or reconnect Google Calendar. Do not fetch the returned URL as an API; the signed-in user must open it in their browser.",
+  schema: z.object({
+    addAccount: z
+      .boolean()
+      .optional()
+      .describe(
+        "Use true only when adding another Google Calendar account to an already connected Calendar workspace.",
+      ),
+    returnPath: z
+      .string()
+      .optional()
+      .describe(
+        "Optional same-origin Calendar path to return to after the Google OAuth flow.",
+      ),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  parallelSafe: true,
+  run: async (args) => {
+    const owner = getRequestUserEmail();
+    if (!owner) {
+      throw new Error("Sign in to Calendar before connecting Google Calendar.");
+    }
+
+    const path = args.addAccount ? ADD_ACCOUNT_PATH : CONNECT_PATH;
+    const params = new URLSearchParams({ redirect: "1" });
+    if (!args.addAccount) params.set("calendar", "1");
+
+    const returnPath = normalizeReturnPath(args.returnPath);
+    if (returnPath) params.set("return", returnPath);
+
+    const url = `${path}?${params.toString()}`;
+    const label = args.addAccount
+      ? "Add Google Calendar account"
+      : "Connect Google Calendar";
+    return {
+      provider: "google_calendar",
+      url,
+      label,
+      markdown: `[${label}](${url})`,
+      message:
+        "Open this link in the signed-in Calendar browser session to connect Google Calendar. Do not fetch it from the agent backend.",
+      requiresUserGesture: true,
+    };
+  },
+  link: ({ result }) => {
+    const url =
+      result && typeof result === "object"
+        ? (result as { url?: unknown }).url
+        : null;
+    if (typeof url !== "string" || !url) return null;
+    return {
+      url,
+      label: "Connect Google Calendar",
+      view: "settings",
+    };
+  },
+});

package/corpus/templates/calendar/changelog/2026-06-30-calendar-now-gives-the-agent-a-safe-google-connection-link-i.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-30
+---
+
+Calendar now gives the agent a safe Google connection link instead of surfacing a raw auth error.

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

@@ -70,6 +70,7 @@ const INITIAL_TOOL_NAMES = [
   "find-a-time",
   "search-people",
   "navigate",
+  "connect-google-calendar",
   "list-booking-links",
   "create-booking-link",
   "update-booking-link",
@@ -111,6 +112,7 @@ Provider-specific Calendar actions are shortcuts, not limits. If a first-class a
 - \`pnpm action navigate --view=calendar --date=YYYY-MM-DD\` — Navigate to a specific date
 - \`pnpm action navigate --view=availability\` — Show availability settings
 - \`pnpm action navigate --view=booking-links\` — Show booking links
+- \`pnpm action connect-google-calendar\` — Create a user-clickable Google Calendar OAuth link. Use this when the user asks to connect or reconnect Google Calendar. Do not fetch \`/_agent-native/google/auth-url\` yourself; OAuth must be opened by the signed-in user in their browser.
 - \`pnpm action update-calendar-visual-preferences --colorMode multi\` — Color the local app UI by meeting type without modifying Google Calendar events
 - \`pnpm action update-calendar-visual-preferences --colorMode single --singleColor '#5B9BD5'\` — Use one local display color for the user's Google events
 - \`pnpm action check-availability --date YYYY-MM-DD --duration 60\` — Check free slots
@@ -125,6 +127,8 @@ Use \`create-event\` or \`update-event --colorId 1..11\` when the user wants one
 ## Google Connection Check
 Before answering schedule questions, run view-screen first for context, then use list-events for the requested date range even if the user is currently on Settings, Booking Links, or another non-calendar page. Do not infer a Google Calendar connection problem just because the current page is Settings. Only ask the user to reconnect Google if list-events or the explicit Google status reports an auth/connection error.
 
+When the user explicitly asks you to connect or reconnect Google Calendar, call \`connect-google-calendar\` and give them the returned link. Do not call raw HTTP/fetch/web-request against \`/_agent-native/google/auth-url\`; that route depends on the user's browser session and will return 401 from the agent backend.
+
 For relationship-history or frequency questions such as "who have I met at Adobe?" or "how often do I meet with Mattel?", prefer the raw Google Calendar API through provider-api-request so you can choose the exact timeMin/timeMax, q, calendarId, maxResults, and pageToken behavior. Stage large paginated results before analysis. Do not conclude there are no recurring meetings from the visible range or from a convenience action alone.
 
 ## Context Awareness

package/corpus/templates/content/AGENTS.md

@@ -121,7 +121,9 @@ cd templates/content && pnpm action <name> [args]
 | `validate-builder-source-execution`         | `--databaseId <id>` or `--documentId <id> --changeSetId <id> [--idempotencyKey <key>]`                                                                         | Validate/replay a prepared Builder execution gate locally as a dry run; never calls Builder                                             |
 | `execute-builder-source-execution`          | `--databaseId <id>` or `--documentId <id> --changeSetId <id> [--idempotencyKey <key>] [--pushModeConfirmation autosave\|draft\|publish]`                       | Execute a guarded live Builder write only when approved, validated, enabled, idempotent, and targeting `agent-native-blog-article-test` |
 | `add-database-item`                         | `--databaseId <id> [--title <text>] [--propertyValues <json>]`                                                                                                 | Add a page row to a database, optionally seeding property values                                                                        |
-| `duplicate-database-item`                   | `--itemId <id>` or `--documentId <id> [--title <text>]`                                                                                                        | Duplicate a database row page and its stored property values                                                                            |
+| `duplicate-database-item`                   | `--itemId <id>` or `--documentId <id> [--title <text>]`                                                                                                        | Duplicate exactly one database row page and its stored property values; for two or more rows, use `duplicate-database-items` once       |
+| `duplicate-database-items`                  | `--databaseId <id>` or `--documentId <databaseDocumentId> --itemIds <json-array>` or `--documentIds <json-array>`                                              | Preferred multi-row duplicate action; duplicate multiple database row pages atomically and return ordered duplicate item/document IDs   |
+| `delete-database-items`                     | `--databaseId <id>` or `--documentId <databaseDocumentId> --itemIds <json-array>` or `--documentIds <json-array>`                                              | Preferred multi-row delete action; delete multiple database row pages atomically while preserving `delete-document` admin semantics     |
 | `move-database-item`                        | `--itemId <id>` or `--documentId <id> --position <number>`                                                                                                     | Move a database row page to a new zero-based table position                                                                             |
 | `update-content-database-view`              | `--databaseId <id> --viewConfig <json>`                                                                                                                        | Persist database views, sorts, filters, hidden properties, and view settings                                                            |
 | `list-document-properties`                  | `--documentId <id> [--format json]`                                                                                                                            | List Notion-style property definitions and values for a document                                                                        |
@@ -568,11 +570,16 @@ multi-select, users can add a new board group from the board itself; this
 appends a new option to the grouped property definition.
 Use
 `create-content-database`, `get-content-database`,
-`add-database-item`, `duplicate-database-item`, `move-database-item`,
+`add-database-item`, `duplicate-database-item`, `duplicate-database-items`,
+`delete-database-items`, `move-database-item`,
 `update-content-database-view`, `list-document-properties`,
 `configure-document-property`, `set-document-property`,
 `duplicate-document-property`, and `delete-document-property`; do not edit
 property rows or view config via raw SQL when an action can do it.
+When targeting more than one database row, call `duplicate-database-items` or
+`delete-database-items` once with a native JSON array of `itemIds` or
+`documentIds`. Do not loop `duplicate-database-item` or `delete-document` for
+multi-row duplicate/delete requests.
 
 ## UI Components
 

package/corpus/templates/content/actions/_database-row-batch.ts

@@ -0,0 +1,230 @@
+import { and, asc, eq, inArray, isNull, or, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+
+export const DATABASE_ROW_BATCH_LIMIT = 100;
+
+export const databaseRowBatchSchema = z
+  .object({
+    databaseId: z.string().optional().describe("Content database ID"),
+    documentId: z
+      .string()
+      .optional()
+      .describe("Content database backing document ID"),
+    itemIds: z
+      .array(z.string())
+      .max(DATABASE_ROW_BATCH_LIMIT)
+      .optional()
+      .describe(
+        'Native JSON array of database row item IDs to mutate in one batch, for example ["item_1", "item_2"].',
+      ),
+    documentIds: z
+      .array(z.string())
+      .max(DATABASE_ROW_BATCH_LIMIT)
+      .optional()
+      .describe(
+        'Native JSON array of database row document IDs to mutate in one batch, for example ["doc_1", "doc_2"].',
+      ),
+  })
+  .superRefine((value, ctx) => {
+    if (!value.databaseId && !value.documentId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Either databaseId or documentId is required.",
+      });
+    }
+    const total =
+      (value.itemIds?.length ?? 0) + (value.documentIds?.length ?? 0);
+    if (total === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "At least one itemId or documentId is required.",
+      });
+    }
+    if (total > DATABASE_ROW_BATCH_LIMIT) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Database row batch is limited to ${DATABASE_ROW_BATCH_LIMIT} rows.`,
+      });
+    }
+  });
+
+export type DatabaseRowBatchInput = z.infer<typeof databaseRowBatchSchema>;
+
+export type DatabaseRowBatchRow = {
+  item: typeof schema.contentDatabaseItems.$inferSelect;
+  database: typeof schema.contentDatabases.$inferSelect;
+  document: typeof schema.documents.$inferSelect;
+};
+
+function findDuplicates(values: string[]) {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+  for (const value of values) {
+    if (seen.has(value)) duplicates.add(value);
+    seen.add(value);
+  }
+  return [...duplicates];
+}
+
+function positionCaseSql(
+  idColumn: unknown,
+  fallbackColumn: unknown,
+  orderedIds: string[],
+) {
+  const cases = orderedIds.map((id, index) => sql`WHEN ${id} THEN ${index}`);
+  return sql<number>`CASE ${idColumn} ${sql.join(cases, sql` `)} ELSE ${fallbackColumn} END`;
+}
+
+export async function resolveDatabaseRowsForBatch(
+  input: DatabaseRowBatchInput,
+): Promise<{
+  database: typeof schema.contentDatabases.$inferSelect;
+  rows: DatabaseRowBatchRow[];
+}> {
+  const itemIds = input.itemIds ?? [];
+  const documentIds = input.documentIds ?? [];
+  const requestedCount = itemIds.length + documentIds.length;
+  if (!input.databaseId && !input.documentId) {
+    throw new Error("Either databaseId or documentId is required.");
+  }
+  if (requestedCount === 0) {
+    throw new Error("At least one itemId or documentId is required.");
+  }
+  if (requestedCount > DATABASE_ROW_BATCH_LIMIT) {
+    throw new Error(
+      `Database row batch is limited to ${DATABASE_ROW_BATCH_LIMIT} rows.`,
+    );
+  }
+  const duplicateItemIds = findDuplicates(itemIds);
+  const duplicateDocumentIds = findDuplicates(documentIds);
+  if (duplicateItemIds.length > 0 || duplicateDocumentIds.length > 0) {
+    throw new Error("Duplicate database row IDs are not allowed in one batch.");
+  }
+
+  const db = getDb();
+  const [database] = await db
+    .select()
+    .from(schema.contentDatabases)
+    .where(
+      and(
+        input.databaseId
+          ? eq(schema.contentDatabases.id, input.databaseId)
+          : undefined,
+        input.documentId
+          ? eq(schema.contentDatabases.documentId, input.documentId)
+          : undefined,
+        isNull(schema.contentDatabases.deletedAt),
+      ),
+    );
+
+  if (!database) throw new Error("Database not found.");
+
+  const rowPredicates = [];
+  if (itemIds.length > 0) {
+    rowPredicates.push(inArray(schema.contentDatabaseItems.id, itemIds));
+  }
+  if (documentIds.length > 0) {
+    rowPredicates.push(
+      inArray(schema.contentDatabaseItems.documentId, documentIds),
+    );
+  }
+
+  const requestedRows = await db
+    .select({
+      item: schema.contentDatabaseItems,
+      database: schema.contentDatabases,
+      document: schema.documents,
+    })
+    .from(schema.contentDatabaseItems)
+    .innerJoin(
+      schema.contentDatabases,
+      eq(schema.contentDatabases.id, schema.contentDatabaseItems.databaseId),
+    )
+    .innerJoin(
+      schema.documents,
+      eq(schema.documents.id, schema.contentDatabaseItems.documentId),
+    )
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, database.id),
+        rowPredicates.length === 1 ? rowPredicates[0] : or(...rowPredicates),
+        isNull(schema.contentDatabases.deletedAt),
+      ),
+    )
+    .orderBy(asc(schema.contentDatabaseItems.position));
+
+  const itemIdMatches = new Set(requestedRows.map((row) => row.item.id));
+  const documentIdMatches = new Set(
+    requestedRows.map((row) => row.item.documentId),
+  );
+  const missingItemIds = itemIds.filter((id) => !itemIdMatches.has(id));
+  const missingDocumentIds = documentIds.filter(
+    (id) => !documentIdMatches.has(id),
+  );
+  if (missingItemIds.length > 0 || missingDocumentIds.length > 0) {
+    throw new Error("All requested rows must exist in the target database.");
+  }
+
+  if (requestedRows.length !== requestedCount) {
+    throw new Error("Duplicate database row references are not allowed.");
+  }
+
+  const rowIds = requestedRows.map((row) => row.item.id);
+  if (new Set(rowIds).size !== rowIds.length) {
+    throw new Error("Duplicate database row references are not allowed.");
+  }
+
+  return { database, rows: requestedRows };
+}
+
+export async function renumberDatabaseRows(
+  db: ReturnType<typeof getDb>,
+  database: typeof schema.contentDatabases.$inferSelect,
+  now: string,
+) {
+  const rows = await db
+    .select()
+    .from(schema.contentDatabaseItems)
+    .where(eq(schema.contentDatabaseItems.databaseId, database.id))
+    .orderBy(asc(schema.contentDatabaseItems.position));
+  if (rows.length === 0) return;
+
+  const itemIds = rows.map((row) => row.id);
+  const documentIds = rows.map((row) => row.documentId);
+  await db
+    .update(schema.contentDatabaseItems)
+    .set({
+      position: positionCaseSql(
+        schema.contentDatabaseItems.id,
+        schema.contentDatabaseItems.position,
+        itemIds,
+      ),
+      updatedAt: now,
+    })
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, database.id),
+        inArray(schema.contentDatabaseItems.id, itemIds),
+      ),
+    );
+
+  await db
+    .update(schema.documents)
+    .set({
+      position: positionCaseSql(
+        schema.documents.id,
+        schema.documents.position,
+        documentIds,
+      ),
+      updatedAt: now,
+    })
+    .where(
+      and(
+        eq(schema.documents.ownerEmail, database.ownerEmail),
+        eq(schema.documents.parentId, database.documentId),
+        inArray(schema.documents.id, documentIds),
+      ),
+    );
+}

package/corpus/templates/content/actions/_database-utils.ts

@@ -285,8 +285,8 @@ export async function isSoftDeletedDatabaseDocument(documentId: string) {
 export async function getDatabaseByDocumentId(
   documentId: string,
   options: { includeDeleted?: boolean } = {},
+  db = getDb(),
 ) {
-  const db = getDb();
   const clauses = [eq(schema.contentDatabases.documentId, documentId)];
   if (!options.includeDeleted) {
     clauses.push(isNull(schema.contentDatabases.deletedAt));
@@ -301,8 +301,8 @@ export async function getDatabaseByDocumentId(
 export async function getDatabaseItemByDocumentId(
   documentId: string,
   options: { includeDeleted?: boolean } = {},
+  db = getDb(),
 ) {
-  const db = getDb();
   const clauses = [eq(schema.contentDatabaseItems.documentId, documentId)];
   if (!options.includeDeleted) {
     clauses.push(isNull(schema.contentDatabases.deletedAt));
@@ -332,11 +332,15 @@ export async function getDatabaseItemByDocumentId(
 export async function deleteDatabaseDataForDocument(
   documentId: string,
   ownerEmail: string,
+  db = getDb(),
 ) {
-  const db = getDb();
-  const database = await getDatabaseByDocumentId(documentId, {
-    includeDeleted: true,
-  });
+  const database = await getDatabaseByDocumentId(
+    documentId,
+    {
+      includeDeleted: true,
+    },
+    db,
+  );
   if (database) {
     const definitions = await db
       .select({ id: schema.documentPropertyDefinitions.id })
@@ -395,9 +399,13 @@ export async function deleteDatabaseDataForDocument(
       .where(eq(schema.contentDatabases.id, database.id));
   }
 
-  const item = await getDatabaseItemByDocumentId(documentId, {
-    includeDeleted: true,
-  });
+  const item = await getDatabaseItemByDocumentId(
+    documentId,
+    {
+      includeDeleted: true,
+    },
+    db,
+  );
   if (item) {
     await db
       .delete(schema.contentDatabaseBodyHydrationQueue)

package/corpus/templates/content/actions/_notion-action-utils.ts

@@ -0,0 +1,26 @@
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+
+export function getCurrentNotionOwner() {
+  const owner = getRequestUserEmail();
+  if (!owner) throw new Error("no authenticated user");
+  return owner;
+}
+
+export async function getNotionDocumentOwner(documentId: string) {
+  const userEmail = getCurrentNotionOwner();
+  await assertAccess("document", documentId, "editor", {
+    userEmail,
+    orgId: getRequestOrgId(),
+  });
+  return userEmail;
+}
+
+export function resolveDocumentId(args: { documentId?: string; id?: string }) {
+  const documentId = args.documentId || args.id;
+  if (!documentId) throw new Error("documentId is required");
+  return documentId;
+}

package/corpus/templates/content/actions/connect-notion-status.ts

@@ -1,21 +1,30 @@
 import { defineAction } from "@agent-native/core";
-import { getRequestUserEmail } from "@agent-native/core/server";
+import { resolveSecret } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { getNotionConnectionForOwner } from "../server/lib/notion.js";
+import { getCurrentNotionOwner } from "./_notion-action-utils.js";
 
 export default defineAction({
   description: "Check Notion connection status for the current user.",
   schema: z.object({}),
-  http: false,
+  http: { method: "GET" },
   run: async () => {
-    const owner = getRequestUserEmail();
-    if (!owner) throw new Error("no authenticated user");
+    const owner = getCurrentNotionOwner();
     const connection = await getNotionConnectionForOwner(owner);
+    const hasOAuthCredentials = Boolean(
+      (await resolveSecret("NOTION_CLIENT_ID")) &&
+      (await resolveSecret("NOTION_CLIENT_SECRET")),
+    );
+
     return {
       connected: Boolean(connection),
       workspaceName: connection?.workspaceName ?? null,
       workspaceId: connection?.workspaceId ?? null,
+      authUrl: null,
+      error:
+        connection || hasOAuthCredentials ? undefined : "missing_credentials",
+      mode: connection ? ("oauth" as const) : null,
     };
   },
 });

package/corpus/templates/content/actions/create-and-link-notion-page.ts

@@ -0,0 +1,23 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { createAndLinkNotionPage } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Create a Notion page from a Content document and link it.",
+  schema: z.object({
+    documentId: z.string().optional().describe("Document ID (required)"),
+    id: z.string().optional().describe("Alias for --documentId"),
+    parentPageIdOrUrl: z.string().optional(),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    const documentId = resolveDocumentId(args);
+    const owner = await getNotionDocumentOwner(documentId);
+    return createAndLinkNotionPage(owner, documentId, args.parentPageIdOrUrl);
+  },
+});

package/corpus/templates/content/actions/delete-database-items.ts

@@ -0,0 +1,55 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+
+import { getDb } from "../server/db/index.js";
+import {
+  databaseRowBatchSchema,
+  renumberDatabaseRows,
+  resolveDatabaseRowsForBatch,
+} from "./_database-row-batch.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
+import { deleteDocumentRecursive } from "./delete-document.js";
+
+export default defineAction({
+  description:
+    "Delete multiple page rows from a content database in one atomic batch. Use this for two or more selected/named rows instead of looping delete-document.",
+  schema: databaseRowBatchSchema,
+  run: async (args) => {
+    const db = getDb();
+    const { database, rows } = await resolveDatabaseRowsForBatch(args);
+
+    await assertAccess("document", database.documentId, "editor");
+    for (const row of rows) {
+      await assertAccess("document", row.document.id, "admin");
+    }
+
+    const deletedItemIds = rows.map((row) => row.item.id);
+    const deletedDocumentIds = rows.map((row) => row.document.id);
+    const now = new Date().toISOString();
+
+    await db.transaction(async (tx) => {
+      for (const row of rows) {
+        await deleteDocumentRecursive(
+          tx as unknown as ReturnType<typeof getDb>,
+          row.document.id,
+          row.document.ownerEmail,
+        );
+      }
+      await renumberDatabaseRows(
+        tx as unknown as ReturnType<typeof getDb>,
+        database,
+        now,
+      );
+    });
+
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
+    return {
+      ...(await getContentDatabaseResponse(database.id)),
+      deletedItemIds,
+      deletedDocumentIds,
+      deletedCount: deletedItemIds.length,
+    };
+  },
+});

package/corpus/templates/content/actions/delete-document.ts

@@ -12,7 +12,7 @@ import {
   isContentLocalFileMode,
 } from "./_local-file-documents.js";
 
-async function deleteRecursive(
+export async function deleteDocumentRecursive(
   db: ReturnType<typeof getDb>,
   id: string,
   ownerEmail: string,
@@ -29,11 +29,11 @@ async function deleteRecursive(
 
   const deleted: string[] = [];
   for (const child of children) {
-    deleted.push(...(await deleteRecursive(db, child.id, ownerEmail)));
+    deleted.push(...(await deleteDocumentRecursive(db, child.id, ownerEmail)));
   }
 
   // Delete database membership/schema, sync links, versions, shares, then document.
-  await deleteDatabaseDataForDocument(id, ownerEmail);
+  await deleteDatabaseDataForDocument(id, ownerEmail, db);
   await db
     .delete(schema.documentSyncLinks)
     .where(
@@ -86,7 +86,7 @@ export default defineAction({
     const existing = access.resource;
 
     const db = getDb();
-    const deleted = await deleteRecursive(
+    const deleted = await deleteDocumentRecursive(
       db,
       id,
       existing.ownerEmail as string,

package/corpus/templates/content/actions/disconnect-notion.ts

@@ -0,0 +1,16 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { disconnectNotionForOwner } from "../server/lib/notion.js";
+import { getCurrentNotionOwner } from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Disconnect the current user's Notion workspace.",
+  schema: z.object({}),
+  http: { method: "POST" },
+  run: async () => {
+    const owner = getCurrentNotionOwner();
+    const deleted = await disconnectNotionForOwner(owner);
+    return { success: true, deleted };
+  },
+});

package/corpus/templates/content/actions/duplicate-database-item.ts

@@ -11,7 +11,7 @@ import { nanoid } from "./_property-utils.js";
 
 export default defineAction({
   description:
-    "Duplicate a page row in a content database, including stored property values.",
+    "Duplicate exactly one page row in a content database, including stored property values. For two or more rows, use duplicate-database-items once instead of looping this action.",
   schema: z.object({
     itemId: z.string().optional().describe("Database item ID"),
     documentId: z.string().optional().describe("Database row document ID"),