@agent-native/core 0.157.1 → 0.157.3

package/corpus/templates/content/actions/list-content-databases.ts

@@ -1,20 +1,55 @@
 import { defineAction } from "@agent-native/core";
 import { accessFilter } from "@agent-native/core/sharing";
-import { and, asc, eq, isNull, ne, sql } from "drizzle-orm";
+import {
+  and,
+  asc,
+  eq,
+  inArray,
+  isNull,
+  notInArray,
+  or,
+  sql,
+} from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { documentDiscoveryFilter } from "../server/lib/documents.js";
 import type { ListContentDatabasesResponse } from "../shared/api.js";
+import { documentDiscoveryPagination } from "./_document-discovery-query.js";
+
+const DEFAULT_CONTENT_DATABASE_DISCOVERY_LIMIT = 50;
 
 function escapeLike(s: string): string {
   return s.replace(/([\\%_])/g, "\\$1");
 }
 
+export class ContentDatabaseResolutionError extends Error {}
+
 export default defineAction({
   description:
-    "List the content databases the user can access (owned, shared, or org-shared — matching the sidebar) so any of them can be used as a local-table source. Optionally filters by title or excludes one database (e.g. the one being configured).",
+    "Discover one bounded page of ordinary Content databases the user can access from their live title and user-authored description. Returns stable database, document, and space IDs with explicit pagination; follow nextOffset until hasMore is false. Use exact filters before reading a selected database's schema.",
   schema: z.object({
+    spaceId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Exact Content space ID to search within."),
+    databaseId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Exact Content database ID to resolve."),
+    documentId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Exact Content database document/page ID to resolve."),
+    title: z
+      .string()
+      .trim()
+      .min(1)
+      .optional()
+      .describe("Exact live database title to resolve, case-insensitively."),
     excludeDatabaseId: z
       .string()
       .optional()
@@ -23,63 +58,43 @@ export default defineAction({
       .array(z.string())
       .optional()
       .describe("Database ids to omit from the results."),
-    query: z.string().optional().describe("Optional title search text."),
+    query: z
+      .string()
+      .optional()
+      .describe("Optional title or user-authored description search text."),
     limit: z.coerce
       .number()
       .int()
       .min(1)
       .max(50)
-      .optional()
-      .describe("Maximum number of databases to return."),
+      .default(DEFAULT_CONTENT_DATABASE_DISCOVERY_LIMIT)
+      .describe("Maximum number of databases to return. Defaults to 50."),
+    offset: z.coerce
+      .number()
+      .int()
+      .min(0)
+      .default(0)
+      .describe("Zero-based continuation offset."),
   }),
   http: { method: "GET" },
   readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
   run: async (args): Promise<ListContentDatabasesResponse> => {
     const db = getDb();
     const query = args.query?.trim();
     const pattern = query ? `%${escapeLike(query.toLowerCase())}%` : null;
+    const exactTitle = args.title?.toLowerCase();
+    const resolvesExactly = !!(
+      args.databaseId ||
+      args.documentId ||
+      exactTitle
+    );
     const excludedDatabaseIds = new Set(
       [
         args.excludeDatabaseId?.trim(),
         ...(args.excludeDatabaseIds ?? []).map((id) => id.trim()),
       ].filter((id): id is string => !!id),
     );
-    // The same access + discovery filter the sidebar uses, so the picker shows
-    // owned AND shared/org databases and never a trashed/hidden one.
-    const queryBuilder = db
-      .select({
-        id: schema.contentDatabases.id,
-        documentId: schema.contentDatabases.documentId,
-        title: schema.documents.title,
-      })
-      .from(schema.contentDatabases)
-      .innerJoin(
-        schema.documents,
-        eq(schema.contentDatabases.documentId, schema.documents.id),
-      )
-      .where(
-        and(
-          accessFilter(schema.documents, schema.documentShares),
-          isNull(schema.documents.trashedAt),
-          documentDiscoveryFilter(),
-          isNull(schema.contentDatabases.deletedAt),
-          excludedDatabaseIds.size === 1
-            ? ne(
-                schema.contentDatabases.id,
-                Array.from(excludedDatabaseIds)[0]!,
-              )
-            : undefined,
-          pattern
-            ? sql`lower(${schema.documents.title}) LIKE ${pattern} ESCAPE '\\'`
-            : undefined,
-        ),
-      )
-      .orderBy(asc(schema.documents.position));
-
-    const rows = args.limit
-      ? await queryBuilder.limit(args.limit)
-      : await queryBuilder;
-
     const localTableSources =
       excludedDatabaseIds.size > 0
         ? await db
@@ -90,39 +105,165 @@ export default defineAction({
             .from(schema.contentDatabaseSources)
             .where(eq(schema.contentDatabaseSources.sourceType, "local-table"))
         : [];
-    const localTableTargetByDatabaseId = new Map(
-      localTableSources.map((source) => [
-        source.databaseId,
-        source.sourceTable,
-      ]),
-    );
-    const sourceChainIncludesExcludedDatabase = (databaseId: string) => {
-      const seen = new Set<string>();
-      let current: string | undefined = databaseId;
-      while (current && !seen.has(current)) {
-        if (excludedDatabaseIds.has(current)) return true;
-        seen.add(current);
-        current = localTableTargetByDatabaseId.get(current);
+    const excludedDatabaseRows =
+      excludedDatabaseIds.size > 0
+        ? await db
+            .select({ id: schema.contentDatabases.id })
+            .from(schema.contentDatabases)
+            .innerJoin(
+              schema.documents,
+              eq(schema.contentDatabases.documentId, schema.documents.id),
+            )
+            .where(
+              and(
+                accessFilter(schema.documents, schema.documentShares),
+                or(
+                  inArray(
+                    schema.contentDatabases.id,
+                    Array.from(excludedDatabaseIds),
+                  ),
+                  inArray(
+                    schema.contentDatabases.documentId,
+                    Array.from(excludedDatabaseIds),
+                  ),
+                ),
+              ),
+            )
+        : [];
+    const excludedSourceChainDatabaseIds = new Set([
+      ...excludedDatabaseIds,
+      ...excludedDatabaseRows.map((row) => row.id),
+    ]);
+    let expandedSourceChain = true;
+    while (expandedSourceChain) {
+      expandedSourceChain = false;
+      for (const source of localTableSources) {
+        if (
+          excludedSourceChainDatabaseIds.has(source.sourceTable) &&
+          !excludedSourceChainDatabaseIds.has(source.databaseId)
+        ) {
+          excludedSourceChainDatabaseIds.add(source.databaseId);
+          expandedSourceChain = true;
+        }
       }
-      return false;
-    };
+    }
 
-    const databases = rows
-      // Exclusion ids may be database ids OR database document ids — the
-      // settings panel only has the document id before any source exists.
-      .filter(
-        (row) =>
-          !excludedDatabaseIds.has(row.documentId) &&
-          !sourceChainIncludesExcludedDatabase(row.id),
-      )
-      .map((row) => ({
-        databaseId: row.id,
-        documentId: row.documentId,
-        // The document's live title (matches the sidebar) rather than the
-        // possibly-stale content_databases.title.
-        title: row.title ?? "Untitled database",
-      }));
+    // The same access + discovery filter the sidebar uses, so the picker shows
+    // owned AND shared/org databases and never a trashed/hidden one. Resolve
+    // source-chain exclusions before limiting so every page is truthfully full.
+    const where = and(
+      accessFilter(schema.documents, schema.documentShares),
+      isNull(schema.documents.trashedAt),
+      documentDiscoveryFilter(),
+      or(
+        eq(schema.documents.hideFromSearch, 0),
+        isNull(schema.documents.hideFromSearch),
+      ),
+      isNull(schema.contentDatabases.deletedAt),
+      isNull(schema.contentDatabases.systemRole),
+      args.spaceId
+        ? eq(schema.contentDatabases.spaceId, args.spaceId)
+        : undefined,
+      args.databaseId
+        ? eq(schema.contentDatabases.id, args.databaseId)
+        : undefined,
+      args.documentId
+        ? eq(schema.contentDatabases.documentId, args.documentId)
+        : undefined,
+      exactTitle
+        ? sql`lower(${schema.documents.title}) = ${exactTitle}`
+        : undefined,
+      excludedSourceChainDatabaseIds.size > 0
+        ? notInArray(
+            schema.contentDatabases.id,
+            Array.from(excludedSourceChainDatabaseIds),
+          )
+        : undefined,
+      excludedDatabaseIds.size > 0
+        ? notInArray(
+            schema.contentDatabases.documentId,
+            Array.from(excludedDatabaseIds),
+          )
+        : undefined,
+      pattern
+        ? or(
+            sql`lower(${schema.documents.title}) LIKE ${pattern} ESCAPE '\\'`,
+            sql`lower(${schema.documents.description}) LIKE ${pattern} ESCAPE '\\'`,
+          )
+        : undefined,
+    );
+    const baseQuery = () =>
+      db
+        .select({
+          id: schema.contentDatabases.id,
+          documentId: schema.contentDatabases.documentId,
+          title: schema.documents.title,
+          description: schema.documents.description,
+          spaceId: schema.contentDatabases.spaceId,
+        })
+        .from(schema.contentDatabases)
+        .innerJoin(
+          schema.documents,
+          eq(schema.contentDatabases.documentId, schema.documents.id),
+        )
+        .where(where)
+        .orderBy(
+          asc(schema.documents.position),
+          asc(schema.contentDatabases.id),
+        );
+
+    // Two visible matches are sufficient to reject an exact selector without
+    // materializing every duplicate-title row.
+    const rows = resolvesExactly
+      ? await baseQuery().limit(2)
+      : await baseQuery().limit(args.limit).offset(args.offset);
+
+    if (resolvesExactly && rows.length !== 1) {
+      const selector = args.databaseId
+        ? `database ID "${args.databaseId}"`
+        : args.documentId
+          ? `document ID "${args.documentId}"`
+          : `title "${args.title?.trim()}"`;
+      throw new ContentDatabaseResolutionError(
+        rows.length === 0
+          ? `No accessible Content database matched exact ${selector}.`
+          : `Exact ${selector} is ambiguous across multiple accessible Content databases.`,
+      );
+    }
 
-    return { databases };
+    const databases = rows.map((row) => ({
+      databaseId: row.id,
+      documentId: row.documentId,
+      spaceId: row.spaceId,
+      // The document's live title (matches the sidebar) rather than the
+      // possibly-stale content_databases.title.
+      title: row.title ?? "Untitled database",
+      description: row.description,
+    }));
+
+    const totalItems = resolvesExactly
+      ? databases.length
+      : Number(
+          (
+            await db
+              .select({ count: sql<number>`count(*)` })
+              .from(schema.contentDatabases)
+              .innerJoin(
+                schema.documents,
+                eq(schema.contentDatabases.documentId, schema.documents.id),
+              )
+              .where(where)
+          )[0]?.count ?? 0,
+        );
+
+    return {
+      databases,
+      pagination: documentDiscoveryPagination({
+        offset: resolvesExactly ? 0 : args.offset,
+        limit: args.limit,
+        totalItems,
+        returnedItems: databases.length,
+      }),
+    };
   },
 });

package/corpus/templates/content/actions/set-document-property.ts

@@ -28,6 +28,15 @@ import {
 
 export default defineAction({
   description: "Set a Notion-style property value on a document.",
+  publicAgent: {
+    expose: true,
+    readOnly: false,
+    requiresAuth: true,
+    isConsequential: true,
+    title: "Set Content Document Property",
+    description:
+      "Delegate one property update on an existing Content database document.",
+  },
   schema: z.object({
     documentId: z.string().describe("Document ID (required)"),
     databaseId: z

package/corpus/templates/content/actions/submit-content-database-form.ts

@@ -195,6 +195,15 @@ function resolveSubmittedProperties(
 export default defineAction({
   description:
     "Submit one row through a Content database form. Validates that form's required questions, resolves option labels safely, writes the title, Blocks, and property values atomically, verifies the saved row, and returns its exact page link.",
+  publicAgent: {
+    expose: true,
+    readOnly: false,
+    requiresAuth: true,
+    isConsequential: true,
+    title: "Submit Content Database Form",
+    description:
+      "Delegate a validated, atomic submission to an existing Content database form.",
+  },
   schema: submitContentDatabaseFormSchema,
   mcpApp: {
     compactCatalog: true,

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

@@ -290,6 +290,15 @@ export function isStaleBuilderImageSourceComponentSave(args: {
 export default defineAction({
   description:
     "Update an existing document's title, content, icon, or favorite status.",
+  publicAgent: {
+    expose: true,
+    readOnly: false,
+    requiresAuth: true,
+    isConsequential: true,
+    title: "Update Content Document",
+    description:
+      "Delegate a sparse update to an existing Content document while preserving omitted fields.",
+  },
   schema: z.object({
     id: z.string().optional().describe("Document ID (required)"),
     title: z.string().optional().describe("New title"),

package/corpus/templates/content/app/components/editor/database/DatabaseView.tsx

@@ -113,6 +113,7 @@ import {
 import { Link, useLocation, useNavigate } from "react-router";
 import { toast } from "sonner";
 
+import { QueryErrorState } from "@/components/QueryErrorState";
 import {
   contentSpaceForCatalogItem,
   createContentSpaceSelectionQueue,
@@ -9265,6 +9266,12 @@ function AddSourceView({
             <Spinner className="size-3.5" />
             {dbText("loadingTables")}
           </div>
+        ) : query.isError ? (
+          <QueryErrorState
+            compact
+            onRetry={() => void query.refetch()}
+            retrying={query.isFetching}
+          />
         ) : tables.length === 0 ? (
           <div className="min-w-0 break-words px-2 text-xs text-muted-foreground">
             {dbText("noOtherDatabasesAvailableToAdd")}

package/corpus/templates/content/app/components/editor/database/settings.tsx

@@ -52,6 +52,7 @@ import {
 } from "react";
 import { toast } from "sonner";
 
+import { QueryErrorState } from "@/components/QueryErrorState";
 import { Button } from "@/components/ui/button";
 import {
   DropdownMenu,
@@ -1543,6 +1544,12 @@ function AddSourceView({
             <Spinner className="size-3.5" />
             {dbText("loadingTables")}
           </div>
+        ) : query.isError ? (
+          <QueryErrorState
+            compact
+            onRetry={() => void query.refetch()}
+            retrying={query.isFetching}
+          />
         ) : tables.length === 0 ? (
           <div className="min-w-0 break-words px-2 text-xs text-muted-foreground">
             {dbText("noOtherDatabasesAvailableToAdd")}

package/corpus/templates/content/app/hooks/use-content-database.ts

@@ -1,4 +1,5 @@
 import {
+  callAction,
   useActionMutation,
   useActionQuery,
 } from "@agent-native/core/client/hooks";
@@ -56,7 +57,7 @@ import type {
   ValidateBuilderSourceExecutionRequest,
 } from "@shared/api";
 import type { Query, QueryClient } from "@tanstack/react-query";
-import { useQueryClient } from "@tanstack/react-query";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
 
 import { documentQueryFilter } from "../lib/document-query";
 
@@ -1390,16 +1391,95 @@ export function useContentDatabases(args: {
   excludeDatabaseIds?: string[];
   enabled: boolean;
 }) {
-  return useActionQuery<ListContentDatabasesResponse>(
-    "list-content-databases",
-    args.enabled
-      ? {
-          excludeDatabaseId: args.excludeDatabaseId ?? undefined,
-          excludeDatabaseIds: args.excludeDatabaseIds ?? undefined,
-        }
-      : undefined,
-    { enabled: args.enabled, retry: false },
-  );
+  const filters = {
+    excludeDatabaseId: args.excludeDatabaseId ?? undefined,
+    excludeDatabaseIds: args.excludeDatabaseIds ?? undefined,
+  };
+  return useQuery({
+    queryKey: ["action", "list-content-databases", filters],
+    queryFn: async ({ signal }) => ({
+      databases: await fetchCompleteContentDatabaseList((offset, limit) =>
+        callAction<ListContentDatabasesResponse>(
+          "list-content-databases",
+          { ...filters, offset, limit },
+          { method: "GET", signal },
+        ),
+      ),
+    }),
+    enabled: args.enabled,
+    retry: false,
+  });
+}
+
+const CONTENT_DATABASE_LIST_PAGE_SIZE = 50;
+
+export async function fetchCompleteContentDatabaseList(
+  fetchPage: (
+    offset: number,
+    limit: number,
+  ) => Promise<ListContentDatabasesResponse>,
+) {
+  const databases: ListContentDatabasesResponse["databases"] = [];
+  const databaseIds = new Set<string>();
+  let offset = 0;
+  let expectedTotal: number | null = null;
+
+  while (true) {
+    const page = await fetchPage(offset, CONTENT_DATABASE_LIST_PAGE_SIZE);
+    const { pagination } = page;
+    if (!pagination) {
+      throw new Error(
+        "list-content-databases returned no pagination boundary; refusing to treat the result as complete.",
+      );
+    }
+    if (
+      pagination.offset !== offset ||
+      pagination.limit !== CONTENT_DATABASE_LIST_PAGE_SIZE ||
+      pagination.returnedItems !== page.databases.length
+    ) {
+      throw new Error(
+        "list-content-databases returned inconsistent pagination metadata; retry the complete read.",
+      );
+    }
+    if (expectedTotal === null) expectedTotal = pagination.totalItems;
+    if (pagination.totalItems !== expectedTotal) {
+      throw new Error(
+        "Content databases changed during paginated discovery; retry the complete read.",
+      );
+    }
+    for (const database of page.databases) {
+      if (databaseIds.has(database.databaseId)) {
+        throw new Error(
+          `list-content-databases repeated database "${database.databaseId}" across pages; refusing an ambiguous result.`,
+        );
+      }
+      databaseIds.add(database.databaseId);
+      databases.push(database);
+    }
+
+    const expectedNextOffset = offset + page.databases.length;
+    if (!pagination.hasMore) {
+      if (
+        pagination.nextOffset !== null ||
+        expectedNextOffset !== expectedTotal ||
+        databases.length !== expectedTotal
+      ) {
+        throw new Error(
+          "list-content-databases claimed exhaustion before every declared database was returned.",
+        );
+      }
+      return databases;
+    }
+    if (
+      pagination.nextOffset !== expectedNextOffset ||
+      pagination.nextOffset <= offset
+    ) {
+      throw new Error(
+        "list-content-databases returned a non-advancing continuation; refusing a clipped result.",
+      );
+    }
+    offset = pagination.nextOffset;
+  }
 }
 
 export function useSuggestSourceJoinKey(args: {

package/corpus/templates/content/parity/matrix.md

@@ -6,7 +6,7 @@ This generated matrix tracks whether high-value Content UI operations use the sa
 | -------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------- | -------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------------------ |
 | comments.threads                                   | comments    | List, add, reply, resolve, reopen, and delete comment threads                                             | action-backed         | `add-comment`, `delete-comment`, `list-comments`, `update-comment`                                                                                                                                                                                                                                                                                                                                          | `app/components/editor/CommentsSidebar.tsx`, `app/hooks/use-comments.ts`                                                                                                                  | Comment threads, replies, anchors, mentions, resolution state, and deletion are stored through comment actions.                                                                                                                                                                           | -                                                                                                                                                                                                                                          | -                | P0             | seeded        | -                                                                                                                                                                                                                       | -                                | -                              |
 | database.form-submissions                          | database    | Submit public database forms as new rows                                                                  | action-backed         | `submit-content-database-form`                                                                                                                                                                                                                                                                                                                                                                              | `app/components/editor/database/FormView.tsx`                                                                                                                                             | A validated form submission atomically creates a database row document and its editable property values.                                                                                                                                                                                  | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/submit-content-database-form.db.test.ts`                                                                                                                                                                       | -                                | -                              |
-| database.lifecycle-and-trash                       | database    | Create, soft-delete, restore, list, and inspect content databases                                         | action-backed         | `create-content-database`, `create-inline-content-database`, `delete-content-database`, `get-content-database`, `list-content-databases`, `list-trashed-content-databases`, `restore-content-database`                                                                                                                                                                                                      | `app/components/editor/SlashCommandMenu.tsx`, `app/hooks/use-content-database.ts`, `app/hooks/use-documents.ts`                                                                           | Database pages and database records are created, read, soft-deleted, restored, and listed.                                                                                                                                                                                                | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/content-database-lifecycle.db.test.ts`                                                                                                                                                                         | `database-source-scope`          | -                              |
+| database.lifecycle-and-trash                       | database    | Create, soft-delete, restore, list, and inspect content databases                                         | action-backed         | `create-content-database`, `create-inline-content-database`, `delete-content-database`, `describe-content-database`, `get-content-database`, `list-content-databases`, `list-trashed-content-databases`, `restore-content-database`                                                                                                                                                                         | `app/components/editor/SlashCommandMenu.tsx`, `app/hooks/use-content-database.ts`, `app/hooks/use-documents.ts`                                                                           | Database pages and database records are created, read, soft-deleted, restored, and listed.                                                                                                                                                                                                | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/content-database-lifecycle.db.test.ts`, `actions/list-content-databases.db.test.ts`, `server/plugins/agent-chat.spec.ts`, `../../packages/core/src/server/agent-chat/content-a2a-capabilities.spec.ts`         | `database-source-scope`          | -                              |
 | database.private-preview-drafts                    | database    | Persist and reconcile a user's private database-page preview draft                                        | action-backed         | `get-preview-document-draft`, `update-preview-document-draft`                                                                                                                                                                                                                                                                                                                                               | `app/components/editor/database/DatabaseView.tsx`, `app/hooks/use-documents.ts`                                                                                                           | A user's private preview draft is read, saved, conflict-checked, or deleted without changing the shared database page until the normal save flow applies it.                                                                                                                              | These per-user editor-state actions are intentionally hidden from agent tools because preview drafts are a private UI recovery mechanism.                                                                                                  | -                | P1             | covered       | `actions/preview-document-draft.db.test.ts`                                                                                                                                                                             | -                                | -                              |
 | database.properties-and-view-config                | database    | Configure properties, values, ordering, and saved views                                                   | action-backed         | `configure-document-property`, `delete-document-property`, `duplicate-document-property`, `get-content-database-personal-view`, `list-document-properties`, `reorder-document-property`, `set-document-property`, `update-content-database-personal-view`, `update-content-database-view`                                                                                                                   | `app/components/editor/DocumentProperties.tsx`, `app/components/editor/DocumentDatabase.tsx`, `app/components/editor/database/DatabaseView.tsx`, `app/hooks/use-document-properties.ts`   | Property schemas, property values, property order, filters, sorts, grouping, hidden columns, view type, and view settings are stored.                                                                                                                                                     | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/bind-content-database-source-field.db.test.ts`, `actions/content-database-source-actions.test.ts`, `actions/resync-content-database-source.db.test.ts`                                                         | `database-source-scope`          | -                              |
 | database.rows                                      | database    | Add, duplicate, move, open, edit, and remove database rows                                                | action-backed         | `add-database-item`, `update-database-item`, `upsert-database-item-by-key`, `remove-database-items`, `duplicate-database-items`, `duplicate-database-item`, `migrate-content-database-rows`, `move-database-item`, `set-document-property`                                                                                                                                                                  | `app/components/editor/DocumentDatabase.tsx`, `app/components/editor/database/DatabaseView.tsx`                                                                                           | Database row memberships and ordering are created, duplicated, moved, edited, and removed without deleting the backing page; bounded migrations atomically update row bodies and properties through the same canonical data model.                                                        | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/database-row-batch-actions.db.test.ts`, `actions/upsert-database-item-by-key.db.test.ts`, `actions/migrate-content-database-rows.db.test.ts`, `parity/__tests__/database-row-batch-reliability.test.ts`        | `database-bulk-row-reliability`  | -                              |

package/corpus/templates/content/parity/matrix.ts

@@ -275,6 +275,7 @@ export const parityMatrix: ParityRow[] = [
       "create-content-database",
       "create-inline-content-database",
       "delete-content-database",
+      "describe-content-database",
       "get-content-database",
       "list-content-databases",
       "list-trashed-content-databases",
@@ -285,7 +286,12 @@ export const parityMatrix: ParityRow[] = [
     spinePriority: "P0",
     testCoverage: "covered",
     followUpPR: null,
-    coverageRefs: ["actions/content-database-lifecycle.db.test.ts"],
+    coverageRefs: [
+      "actions/content-database-lifecycle.db.test.ts",
+      "actions/list-content-databases.db.test.ts",
+      "server/plugins/agent-chat.spec.ts",
+      "../../packages/core/src/server/agent-chat/content-a2a-capabilities.spec.ts",
+    ],
     evalScenarioIds: ["database-source-scope"],
   },
   {

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

@@ -34,6 +34,9 @@ export default createAgentChatPlugin({
   durableBackgroundRuns: true,
   actions: loadActionsFromStaticRegistry(actionsRegistry),
   initialToolNames: INITIAL_TOOL_NAMES,
+  mcp: {
+    connectorCatalog: ["list-content-databases", "describe-content-database"],
+  },
   anonymousOwner: resolvePublicViewerOwner,
   extraContext: publicDocumentExtraContext,
   // Enable sandboxed JavaScript execution so Content agents can fetch,

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

@@ -1077,11 +1077,20 @@ export interface ChangeContentDatabaseSourceRoleRequest {
 export interface ContentDatabaseSummary {
   databaseId: string;
   documentId: string;
+  spaceId: string | null;
   title: string;
+  description: string;
+}
+
+export interface ContentDatabaseDescriptionResponse {
+  database: ContentDatabase;
+  contextPath: ContentContextPathEntry[];
+  properties: DocumentProperty[];
 }
 
 export interface ListContentDatabasesResponse {
   databases: ContentDatabaseSummary[];
+  pagination: DocumentDiscoveryPagination;
 }
 
 export interface TrashedContentDatabaseSummary {

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
+    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
-    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
+    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
-    error?: undefined;
 }>>;