@agent-native/core 0.197.0-nightly-20260929180759 → 0.197.0

package/corpus/templates/content/actions/search-content-database-rows.ts

@@ -0,0 +1,124 @@
+import { defineAction } from "@agent-native/core/action";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, asc, count, eq, isNull, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { getDatabaseMutationContract } from "./_database-row-mutation.js";
+import { resolveContentDatabaseRead } from "./_database-utils.js";
+import { documentDiscoveryPagination } from "./_document-discovery-query.js";
+
+function escapeLike(s: string): string {
+  return s.replace(/([\\%_])/g, "\\$1");
+}
+
+export default defineAction({
+  description:
+    "Search one Content collection's rows by title. Returns row document IDs to use as relation property values, in collection order, with explicit pagination.",
+  mcpTool: true,
+  schema: z.object({
+    databaseId: z.string().min(1).describe("Exact Content collection ID"),
+    query: z
+      .string()
+      .max(200)
+      .optional()
+      .describe("Optional case-insensitive title search text"),
+    limit: z.coerce.number().int().min(1).max(50).default(25),
+    offset: z.coerce.number().int().min(0).default(0),
+  }),
+  http: { method: "GET" },
+  run: async (args) => {
+    const resolution = await resolveContentDatabaseRead({
+      databaseId: args.databaseId,
+    });
+    if (!resolution.available) throw new Error(resolution.message);
+    const database = resolution.database;
+    if (database.systemRole) {
+      throw new Error("System collections cannot be linked.");
+    }
+
+    const db = getDb();
+    const query = args.query?.trim().toLowerCase() ?? "";
+    const where = and(
+      eq(schema.contentDatabaseItems.databaseId, database.id),
+      isNull(schema.documents.trashedAt),
+      query
+        ? sql`lower(${schema.documents.title}) like ${`%${escapeLike(query)}%`} escape '\\'`
+        : undefined,
+    );
+    const rows = await db
+      .select({
+        documentId: schema.documents.id,
+        title: schema.documents.title,
+        icon: schema.documents.icon,
+      })
+      .from(schema.contentDatabaseItems)
+      .innerJoin(
+        schema.documents,
+        eq(schema.documents.id, schema.contentDatabaseItems.documentId),
+      )
+      .where(where)
+      .orderBy(
+        asc(schema.contentDatabaseItems.position),
+        asc(schema.contentDatabaseItems.id),
+      )
+      .limit(args.limit)
+      .offset(args.offset);
+    const [total] = await db
+      .select({ value: count() })
+      .from(schema.contentDatabaseItems)
+      .innerJoin(
+        schema.documents,
+        eq(schema.documents.id, schema.contentDatabaseItems.documentId),
+      )
+      .where(where);
+
+    // Editors may create a new row from the picker; hand them the target and
+    // schema revision add-database-item needs.
+    let rowCreation: {
+      target: Awaited<ReturnType<typeof getDatabaseMutationContract>>["target"];
+      schemaRevision: string;
+    } | null = null;
+    if (database.spaceId) {
+      const canEdit = await assertAccess(
+        "document",
+        database.documentId,
+        "editor",
+      ).then(
+        () => true,
+        () => false,
+      );
+      if (canEdit) {
+        const contract = await getDatabaseMutationContract({
+          spaceId: database.spaceId,
+          databaseId: database.id,
+          databaseDocumentId: database.documentId,
+          authorityScope: database.orgId
+            ? { kind: "organization", id: database.orgId }
+            : { kind: "personal", id: database.ownerEmail },
+        });
+        rowCreation = {
+          target: contract.target,
+          schemaRevision: contract.schemaRevision,
+        };
+      }
+    }
+
+    return {
+      databaseId: database.id,
+      databaseDocumentId: database.documentId,
+      rowCreation,
+      rows: rows.map((row) => ({
+        documentId: row.documentId,
+        title: row.title || "Untitled",
+        icon: row.icon ?? null,
+      })),
+      pagination: documentDiscoveryPagination({
+        offset: args.offset,
+        limit: args.limit,
+        totalItems: Number(total?.value ?? 0),
+        returnedItems: rows.length,
+      }),
+    };
+  },
+});

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

@@ -12,6 +12,8 @@ import {
   isComputedPropertyType,
   normalizePropertyValue,
   parsePropertyOptions,
+  parsePropertyValue,
+  serializePropertyValue,
   type DocumentPropertyType,
 } from "../shared/properties.js";
 import { contentDatabaseSourceFieldsAllowLocalWrite } from "../shared/source-field-policy.js";
@@ -28,6 +30,7 @@ import {
   nanoid,
   normalizedValueJson,
 } from "./_property-utils.js";
+import { validateRelationWrite } from "./_relation-values.js";
 
 async function assertPropertyWritableByRowMutation(
   db: ReturnType<typeof getDb>,
@@ -276,7 +279,7 @@ export default defineAction({
       };
     }
 
-    const valueJson = normalizedValueJson(type, value);
+    let valueJson = normalizedValueJson(type, value);
     await db.transaction(async (tx) => {
       await lockContentDatabaseMutation(
         tx as unknown as ReturnType<typeof getDb>,
@@ -337,6 +340,23 @@ export default defineAction({
         database.id,
         lockedDefinition,
       );
+      if (lockedType === "relation") {
+        const [stored] = await tx
+          .select({ valueJson: schema.documentPropertyValues.valueJson })
+          .from(schema.documentPropertyValues)
+          .where(
+            and(
+              eq(schema.documentPropertyValues.documentId, documentId),
+              eq(schema.documentPropertyValues.propertyId, propertyId),
+            ),
+          );
+        const ids = await validateRelationWrite(tx, {
+          definition: lockedDefinition,
+          nextValue: value,
+          previousValue: parsePropertyValue(stored?.valueJson),
+        });
+        valueJson = serializePropertyValue(ids);
+      }
       const isNaturalKey = lockedDatabase.naturalKeyPropertyId === propertyId;
       if (isNaturalKey) {
         let parsed: unknown;

package/corpus/templates/content/agent-native.config.ts

@@ -0,0 +1,5 @@
+import { defineAgentNativeConfig } from "@agent-native/core/config";
+
+export default defineAgentNativeConfig({
+  changelog: { enabled: true },
+});