@stigmer/mcp-server 3.2.3 → 3.4.0

package/src/domains/records/errors.ts

@@ -0,0 +1,98 @@
+// The records-domain error mapper (DD-005 SD-6) — a deliberate,
+// documented divergence from the shared ../rpcerr.ts.
+//
+// Record-RPC domain errors carry agent-relayable messages that are
+// cross-edition contract bytes (DD-002 SD-5): "that slot is already
+// booked", "you are not allowed to insert records in bookings". The
+// shared helper would rewrite them ("Check your API key permissions")
+// and discards google.rpc.ErrorInfo. Here the domain codes pass the
+// server's message through VERBATIM as isError JSON text
+// `{error, code, reason, constraint}` — reason/constraint extracted
+// from ErrorInfo — so the model can self-correct (retry another slot
+// on CONSTRAINT_VIOLATION; stop and relay on PERMISSION_DENIED).
+// Transport codes still delegate to the shared helper, whose advice is
+// right for them.
+
+import { Code, ConnectError } from "@connectrpc/connect";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { ErrorInfoSchema } from "@stigmer/protos/google/rpc/error_details_pb";
+import { rpcError } from "../rpcerr.js";
+import { errorResult, textResult } from "../toolresult.js";
+
+/**
+ * The gRPC codes whose messages are the record-RPC domain contract
+ * (DD-005 SD-6): declared constraint messages, fixed denial texts, and
+ * domain validation — all written to be relayed to end users verbatim.
+ */
+const DOMAIN_CODES: ReadonlySet<Code> = new Set([
+  Code.PermissionDenied,
+  Code.AlreadyExists,
+  Code.FailedPrecondition,
+  Code.InvalidArgument,
+  Code.NotFound,
+]);
+
+/** The structured error payload record tools return for domain errors. */
+export interface RecordToolError {
+  /** The server's relayable message, byte-for-byte. */
+  error: string;
+  /** gRPC status name in SCREAMING_SNAKE (e.g. ALREADY_EXISTS). */
+  code: string;
+  /** ErrorInfo reason (e.g. CONSTRAINT_VIOLATION), when present. */
+  reason?: string;
+  /** Violated constraint name from ErrorInfo metadata, when present. */
+  constraint?: string;
+}
+
+/**
+ * Run a record-tool body: a string payload becomes a text result; a
+ * domain error becomes an isError JSON result carrying the verbatim
+ * message + ErrorInfo companions; a transport error delegates to the
+ * shared classifier. The records analog of ../toolresult.ts
+ * textOrError, and the only try/catch in this domain.
+ */
+export async function recordResult(
+  toolContext: string,
+  produce: () => Promise<string>,
+): Promise<CallToolResult> {
+  try {
+    return textResult(await produce());
+  } catch (err) {
+    const ce = ConnectError.from(err);
+    if (DOMAIN_CODES.has(ce.code)) {
+      return {
+        content: [{ type: "text", text: JSON.stringify(domainError(ce)) }],
+        isError: true,
+      };
+    }
+    return errorResult(rpcError(ce, toolContext));
+  }
+}
+
+/** Project a domain ConnectError into the structured tool payload. */
+export function domainError(ce: ConnectError): RecordToolError {
+  const payload: RecordToolError = {
+    error: ce.rawMessage,
+    code: grpcStatusName(ce.code),
+  };
+  // The record RPCs attach one google.rpc.ErrorInfo per domain error
+  // (domain datastore.stigmer.ai); absence means an older server — the
+  // message alone still carries the contract.
+  const details = ce.findDetails(ErrorInfoSchema);
+  if (details.length > 0) {
+    const info = details[0];
+    if (info.reason !== "") {
+      payload.reason = info.reason;
+    }
+    const constraint = info.metadata["constraint"];
+    if (constraint !== undefined && constraint !== "") {
+      payload.constraint = constraint;
+    }
+  }
+  return payload;
+}
+
+/** Connect's PascalCase code name → the gRPC SCREAMING_SNAKE status name. */
+function grpcStatusName(code: Code): string {
+  return Code[code].replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+}

package/src/domains/records/records.integration.test.ts

@@ -0,0 +1,313 @@
+// In-process integration test for the record tools (search-pattern:
+// real Connect backend with stubbed record services, real MCP client
+// over an in-memory transport).
+//
+// Verifies the T05 contract surface:
+//   - the records-only roster is exactly the five tools (T05 R1), with
+//     honest annotations surfaced through tools/list (pinning the SDK's
+//     annotations support) and NO org argument (agent audience);
+//   - the main roster carries the same five tools WITH the org argument
+//     (direct audience);
+//   - argument → request mapping (typed filter, "in" → is_in, paging);
+//   - the records-own error mapper: domain errors pass the server's
+//     message verbatim as {error, code, reason, constraint} JSON with
+//     ErrorInfo companions; transport errors delegate to the shared
+//     classifier (DD-005 SD-6).
+
+import { create } from "@bufbuild/protobuf";
+import { Code, ConnectError, type ConnectRouter } from "@connectrpc/connect";
+import { connectNodeAdapter } from "@connectrpc/connect-node";
+import {
+  createServer as createHttp2Server,
+  type Http2Server,
+  type ServerHttp2Session,
+} from "node:http2";
+import type { AddressInfo } from "node:net";
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { DatastoreRecordCommandController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_command_pb";
+import {
+  DatastoreDescriptionSchema,
+  RecordEnvelopeSchema,
+  RecordListSchema,
+  type FindRecordsRequest,
+  type InsertRecordRequest,
+} from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_io_pb";
+import { DatastoreRecordQueryController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_query_pb";
+import { ErrorInfoSchema } from "@stigmer/protos/google/rpc/error_details_pb";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import { configureLogger } from "../../logger";
+import { createRecordsServer, createServer } from "../../server";
+
+configureLogger({ level: "error", format: "text" });
+
+const RECORD_TOOLS = [
+  "describe_datastore",
+  "find_records",
+  "insert_record",
+  "update_record",
+  "delete_record",
+];
+
+let backend: Http2Server;
+let client: Client;
+const openSessions = new Set<ServerHttp2Session>();
+
+/** The next stubbed outcome per RPC; tests set these. */
+let findResponse: () => ReturnType<typeof create<typeof RecordListSchema>>;
+let insertOutcome: () => ReturnType<typeof create<typeof RecordEnvelopeSchema>>;
+
+/**
+ * Requests the stubs captured. An object (not two `let`s) because TS
+ * does not reset let-narrowing across awaited calls for closure
+ * assignments — property narrowing it does.
+ */
+const captured: {
+  find?: FindRecordsRequest;
+  insert?: InsertRecordRequest;
+} = {};
+
+interface ToolResult {
+  content: Array<{ type: string; text?: string }>;
+  isError?: boolean;
+}
+
+async function callTool(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+  return (await client.callTool({ name, arguments: args })) as ToolResult;
+}
+
+beforeAll(async () => {
+  const routes = (router: ConnectRouter) => {
+    router.service(DatastoreRecordQueryController, {
+      findRecords: (req) => {
+        captured.find = req;
+        return findResponse();
+      },
+      describeDatastore: () =>
+        create(DatastoreDescriptionSchema, {
+          datastore: "clinic",
+          timezone: "Asia/Kolkata",
+          partitions: ["default"],
+        }),
+    });
+    router.service(DatastoreRecordCommandController, {
+      insertRecord: (req) => {
+        captured.insert = req;
+        return insertOutcome();
+      },
+      updateRecord: () => create(RecordEnvelopeSchema, { id: "dsr_updated" }),
+      deleteRecord: () => create(RecordEnvelopeSchema, { id: "dsr_deleted" }),
+    });
+  };
+  backend = createHttp2Server(connectNodeAdapter({ routes }));
+  backend.on("session", (session) => {
+    openSessions.add(session);
+    session.on("close", () => openSessions.delete(session));
+  });
+  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
+  const port = (backend.address() as AddressInfo).port;
+
+  // The records-only roster is the surface under test — the audience
+  // the runner-synthesized attachment serves.
+  const mcp = createRecordsServer({ serverAddress: `127.0.0.1:${port}`, apiKey: "" });
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  client = new Client({ name: "records-integration", version: "test" });
+  await Promise.all([mcp.connect(serverTransport), client.connect(clientTransport)]);
+});
+
+afterAll(async () => {
+  await client?.close();
+  for (const session of openSessions) session.destroy();
+  await new Promise<void>((resolve) => backend.close(() => resolve()));
+});
+
+describe("records roster (T05 R1)", () => {
+  it("exposes exactly the five record tools with honest annotations and no org argument", async () => {
+    const { tools } = await client.listTools();
+    expect(tools.map((t) => t.name).sort()).toEqual([...RECORD_TOOLS].sort());
+
+    const byName = new Map(tools.map((t) => [t.name, t]));
+    // Annotations are part of the DD-005 contract for external clients
+    // and the classifier; this pins the SDK actually surfacing them.
+    expect(byName.get("find_records")?.annotations).toMatchObject({ readOnlyHint: true });
+    expect(byName.get("describe_datastore")?.annotations).toMatchObject({ readOnlyHint: true });
+    expect(byName.get("update_record")?.annotations).toMatchObject({ idempotentHint: true });
+    expect(byName.get("delete_record")?.annotations).toMatchObject({
+      destructiveHint: true,
+      idempotentHint: true,
+    });
+
+    // The agent audience gets no org argument — a session-bound
+    // caller's org is server-derived, and offering the argument would
+    // only invite INVALID_ARGUMENT rejections (T05 R3).
+    for (const tool of tools) {
+      const properties = (tool.inputSchema as { properties?: Record<string, unknown> }).properties;
+      expect(Object.keys(properties ?? {}), tool.name).not.toContain("org");
+    }
+  });
+
+  it("the main roster carries the five tools WITH the org argument", async () => {
+    // Direct principals (external MCP clients) must be able to name the
+    // org their credential does not carry (DD-006 session-14 amendment).
+    const full = createServer({ serverAddress: "127.0.0.1:1", apiKey: "" });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const fullClient = new Client({ name: "records-full-roster", version: "test" });
+    await Promise.all([full.connect(serverTransport), fullClient.connect(clientTransport)]);
+    try {
+      const { tools } = await fullClient.listTools();
+      const names = tools.map((t) => t.name);
+      for (const name of RECORD_TOOLS) {
+        expect(names).toContain(name);
+      }
+      const find = tools.find((t) => t.name === "find_records");
+      const properties = (find?.inputSchema as { properties?: Record<string, unknown> })
+        .properties;
+      expect(Object.keys(properties ?? {})).toContain("org");
+    } finally {
+      await fullClient.close();
+    }
+  });
+});
+
+describe("argument → request mapping", () => {
+  it("builds the typed filter (in → is_in), order_by, and paging", async () => {
+    findResponse = () =>
+      create(RecordListSchema, {
+        records: [create(RecordEnvelopeSchema, { id: "dsr_1" })],
+        total: 1,
+        limit: 25,
+      });
+    captured.find = undefined;
+
+    const result = await callTool("find_records", {
+      datastore: "clinic",
+      collection: "bookings",
+      conditions: [
+        { field: "status", op: "eq", value: "confirmed" },
+        { field: "patient_name", op: "in", values: ["Asha", "Ravi"] },
+      ],
+      order_by: { field: "slot_start", direction: "desc" },
+      limit: 10,
+      offset: 20,
+    });
+
+    expect(result.isError).toBeFalsy();
+    // Assertion, not annotation: control-flow analysis otherwise pins the
+    // const to the `= undefined` reset above (the stub assigns in a
+    // closure the analysis cannot see across the await).
+    const req = captured.find as FindRecordsRequest | undefined;
+    expect(req?.datastore).toBe("clinic");
+    expect(req?.org).toBe(""); // agent audience: org never travels
+    expect(req?.partition).toBe(""); // partition is never a tool argument (DD-010)
+    expect(req?.filter?.conditions).toHaveLength(2);
+    expect(req?.filter?.conditions[0]).toMatchObject({ field: "status", op: 1 /* eq */ });
+    expect(req?.filter?.conditions[1]).toMatchObject({ field: "patient_name", op: 7 /* is_in */ });
+    expect(req?.filter?.conditions[1]?.values).toHaveLength(2);
+    expect(req?.orderBy).toMatchObject({ field: "slot_start", direction: 2 /* desc */ });
+    expect(req?.limit).toBe(10);
+    expect(req?.offset).toBe(20);
+
+    const body = JSON.parse(result.content[0]?.text ?? "{}") as { total?: number };
+    expect(body.total).toBe(1);
+  });
+
+  it("passes the record payload through as a Struct, untouched", async () => {
+    insertOutcome = () => create(RecordEnvelopeSchema, { id: "dsr_new" });
+    captured.insert = undefined;
+
+    const result = await callTool("insert_record", {
+      datastore: "clinic",
+      collection: "bookings",
+      record: { slot_start: "2026-07-21T04:30:00Z", patient_name: "Asha" },
+    });
+
+    expect(result.isError).toBeFalsy();
+    const req = captured.insert as InsertRecordRequest | undefined;
+    expect(req?.record).toMatchObject({
+      slot_start: "2026-07-21T04:30:00Z",
+      patient_name: "Asha",
+    });
+  });
+});
+
+describe("records error mapper (DD-005 SD-6)", () => {
+  it("passes a constraint violation through verbatim with ErrorInfo companions", async () => {
+    insertOutcome = () => {
+      throw new ConnectError("that slot is already booked", Code.AlreadyExists, undefined, [
+        {
+          desc: ErrorInfoSchema,
+          value: create(ErrorInfoSchema, {
+            reason: "CONSTRAINT_VIOLATION",
+            domain: "datastore.stigmer.ai",
+            metadata: { constraint: "one_confirmed_per_slot" },
+          }),
+        },
+      ]);
+    };
+
+    const result = await callTool("insert_record", {
+      datastore: "clinic",
+      collection: "bookings",
+      record: { slot_start: "2026-07-21T04:30:00Z", patient_name: "Ravi" },
+    });
+
+    expect(result.isError).toBe(true);
+    expect(JSON.parse(result.content[0]?.text ?? "{}")).toEqual({
+      error: "that slot is already booked",
+      code: "ALREADY_EXISTS",
+      reason: "CONSTRAINT_VIOLATION",
+      constraint: "one_confirmed_per_slot",
+    });
+  });
+
+  it("passes a permission denial through verbatim — never the shared rewrite", async () => {
+    insertOutcome = () => {
+      throw new ConnectError(
+        "you are not allowed to insert records in schedule_exceptions",
+        Code.PermissionDenied,
+        undefined,
+        [
+          {
+            desc: ErrorInfoSchema,
+            value: create(ErrorInfoSchema, {
+              reason: "VERB_DENIED",
+              domain: "datastore.stigmer.ai",
+            }),
+          },
+        ],
+      );
+    };
+
+    const result = await callTool("insert_record", {
+      datastore: "clinic",
+      collection: "schedule_exceptions",
+      record: { exception_date: "2026-07-22" },
+    });
+
+    expect(result.isError).toBe(true);
+    const body = JSON.parse(result.content[0]?.text ?? "{}") as Record<string, string>;
+    // The relayable domain bytes — NOT "Check your API key permissions".
+    expect(body.error).toBe("you are not allowed to insert records in schedule_exceptions");
+    expect(body.code).toBe("PERMISSION_DENIED");
+    expect(body.reason).toBe("VERB_DENIED");
+    expect(body.constraint).toBeUndefined();
+  });
+
+  it("delegates transport codes to the shared classifier", async () => {
+    findResponse = () => {
+      throw new ConnectError("upstream down", Code.Unavailable);
+    };
+
+    const result = await callTool("find_records", {
+      datastore: "clinic",
+      collection: "bookings",
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0]?.text).toBe(
+      "Stigmer server is unavailable. Ensure it is running and reachable.",
+    );
+  });
+});

package/src/domains/records/tools.ts

@@ -0,0 +1,210 @@
+// MCP tools for the Datastore record domain — the five agent-facing
+// record tools of DD-005: 1:1 projections of the record RPCs, with the
+// records-own error mapper (errors.ts) and honest MCP annotations (the
+// bridge's first use of annotations; the platform's own connect-time
+// classifier honors destructiveHint fail-closed for external clients,
+// while the runner-synthesized attachment is approval-free by
+// construction and never passes through that classifier).
+//
+// Two audiences, one definition (registered per roster):
+//   - "agent" (the records-only roster the runner-synthesized
+//     attachment connects to): NO `org` argument — a session-bound
+//     caller's org is server-derived from the session, and an explicit
+//     org is rejected (T05 R3), so offering the argument would only
+//     invite rejected calls.
+//   - "direct" (the main roster external MCP clients see): optional
+//     `org`, which cloud direct principals must name (their credential
+//     carries no ambient org — the DD-006 session-14 amendment). OSS
+//     resolves an empty org to the local system org.
+// `partition` is deliberately NOT a tool argument for either audience
+// (DD-010: never from tool arguments); partition-explicit work is the
+// console/CLI/SDK surface.
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+import { resolveToken, type BackendTarget } from "../client.js";
+import {
+  deleteRecord,
+  describeDatastore,
+  findRecords,
+  insertRecord,
+  updateRecord,
+  type ConditionArg,
+} from "./calls.js";
+import { recordResult } from "./errors.js";
+
+/** Which roster the tools are being registered on (see file header). */
+export type RecordToolAudience = "agent" | "direct";
+
+const ENCODINGS =
+  "Field value encodings: date YYYY-MM-DD, time HH:MM[:SS], timestamp RFC 3339 UTC " +
+  "(e.g. 2026-07-21T04:30:00Z).";
+
+const scalar = z.union([z.string(), z.number(), z.boolean()]);
+
+const conditionShape = z.object({
+  field: z
+    .string()
+    .describe("Declared field name, or a filterable system field (id, created_at, updated_at)."),
+  op: z
+    .enum(["eq", "neq", "gt", "gte", "lt", "lte", "in", "not_in", "is_null", "not_null"])
+    .describe(
+      "Comparison operator. eq/neq/in/not_in for string and enum fields; " +
+        "gt/gte/lt/lte for numeric and temporal fields; is_null/not_null for optional fields.",
+    ),
+  value: scalar
+    .nullable()
+    .optional()
+    .describe("Comparison value for scalar operators, in the field's canonical encoding."),
+  values: z.array(scalar).optional().describe("Comparison values for in / not_in."),
+});
+
+/** Register the five record tools for one audience; returns the tool names. */
+export function registerRecordTools(
+  server: McpServer,
+  target: BackendTarget,
+  audience: RecordToolAudience,
+): string[] {
+  // The org argument exists only on the direct roster (file header).
+  const orgShape: { org?: z.ZodOptional<z.ZodString> } = {};
+  if (audience === "direct") {
+    orgShape.org = z
+      .string()
+      .optional()
+      .describe(
+        "Organization that owns the datastore. Required on Stigmer Cloud; " +
+          "omit against a local backend.",
+      );
+  }
+
+  server.registerTool(
+    "describe_datastore",
+    {
+      description:
+        "Describe a datastore: its collections, field declarations and encodings, constraint " +
+        "messages, data partitions, and the verbs you are allowed to use per collection " +
+        "(empty access means you are not allowed to touch that collection). A read verb may " +
+        "carry readable_fields: reads then return only those fields, and only they may appear " +
+        "in filter conditions and order_by (empty readable_fields means every field). Call " +
+        `this before the first record operation against an unfamiliar datastore. ${ENCODINGS}`,
+      inputSchema: {
+        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
+        ...orgShape,
+      },
+      annotations: { readOnlyHint: true },
+    },
+    (args, extra) =>
+      recordResult(`datastore "${args.datastore}"`, () =>
+        describeDatastore(target.serverAddress, resolveToken(extra, target.apiKey), args),
+      ),
+  );
+
+  server.registerTool(
+    "find_records",
+    {
+      description:
+        "Find records in a datastore collection with a typed filter (conditions are AND-combined). " +
+        "Returns records plus total/limit/offset for paging. Results are ordered by created_at " +
+        "descending unless order_by is given. Records carry only the fields your grant allows " +
+        "(describe_datastore lists them as readable_fields); conditions and order_by on other " +
+        `fields are rejected. ${ENCODINGS}`,
+      inputSchema: {
+        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
+        ...orgShape,
+        collection: z.string().describe("Collection to query (e.g. bookings)."),
+        conditions: z
+          .array(conditionShape)
+          .optional()
+          .describe("Filter conditions, AND-combined. Omit to list all readable records."),
+        order_by: z
+          .object({
+            field: z.string().describe("Field to sort by."),
+            direction: z.enum(["asc", "desc"]).optional().describe("Sort direction (default asc)."),
+          })
+          .optional()
+          .describe("Sort order. Omit for created_at descending with id tiebreak."),
+        limit: z.number().int().optional().describe("Page size (default 25, max 100)."),
+        offset: z.number().int().optional().describe("Records to skip for paging."),
+      },
+      annotations: { readOnlyHint: true },
+    },
+    (args, extra) =>
+      recordResult(`records in "${args.datastore}/${args.collection}"`, () =>
+        findRecords(target.serverAddress, resolveToken(extra, target.apiKey), {
+          ...args,
+          conditions: args.conditions as ConditionArg[] | undefined,
+        }),
+      ),
+  );
+
+  server.registerTool(
+    "insert_record",
+    {
+      description:
+        "Insert one record into a datastore collection. System fields (id, created_at, " +
+        "updated_at, created_by) are server-stamped — never include them. Declared constraints " +
+        "are enforced by the store; a violation returns the constraint's message verbatim " +
+        "(e.g. a taken slot returns ALREADY_EXISTS — pick another, do not retry the same one). " +
+        `When uncertain whether a record already exists, find first. ${ENCODINGS}`,
+      inputSchema: {
+        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
+        ...orgShape,
+        collection: z.string().describe("Collection to insert into (e.g. bookings)."),
+        record: z
+          .record(z.unknown())
+          .describe("Declared fields for the new record, in canonical encodings."),
+      },
+    },
+    (args, extra) =>
+      recordResult(`record in "${args.datastore}/${args.collection}"`, () =>
+        insertRecord(target.serverAddress, resolveToken(extra, target.apiKey), args),
+      ),
+  );
+
+  server.registerTool(
+    "update_record",
+    {
+      description:
+        "Update one record by id with a partial merge: only the supplied fields change, and an " +
+        "explicit null clears a field. Constraints are re-evaluated on the merged result. " +
+        `Returns the full updated record. ${ENCODINGS}`,
+      inputSchema: {
+        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
+        ...orgShape,
+        collection: z.string().describe("Collection holding the record."),
+        id: z.string().describe("Record id (from a previous find or insert)."),
+        fields: z
+          .record(z.unknown())
+          .describe("Fields to merge. Explicit null clears a field; omitted fields keep their values."),
+      },
+      annotations: { idempotentHint: true },
+    },
+    (args, extra) =>
+      recordResult(`record "${args.id}" in "${args.datastore}/${args.collection}"`, () =>
+        updateRecord(target.serverAddress, resolveToken(extra, target.apiKey), args),
+      ),
+  );
+
+  server.registerTool(
+    "delete_record",
+    {
+      description:
+        "Delete one record by id. Returns the deleted record. Record tools never delete " +
+        "collections or datastores.",
+      inputSchema: {
+        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
+        ...orgShape,
+        collection: z.string().describe("Collection holding the record."),
+        id: z.string().describe("Record id (from a previous find or insert)."),
+      },
+      annotations: { destructiveHint: true, idempotentHint: true },
+    },
+    (args, extra) =>
+      recordResult(`record "${args.id}" in "${args.datastore}/${args.collection}"`, () =>
+        deleteRecord(target.serverAddress, resolveToken(extra, target.apiKey), args),
+      ),
+  );
+
+  return ["describe_datastore", "find_records", "insert_record", "update_record", "delete_record"];
+}