@protobase/server 0.36.0 → 0.37.0

package/dist/admin-options.d.ts

@@ -52,6 +52,13 @@ export type AdminOptions = {
   errorReporting?: ErrorReportingOptions | false;
   /** The assistant in the admin app's dock: a backend elsewhere or the built-in one (see `AssistantOptions`); `false` turns it off. */
   assistant?: AssistantOptions | false;
+  /**
+   * The MCP endpoint, on with `createAuth({ mcp })`. `sql: true` also offers admins and the `ai` role
+   * `run_read_only_query`, which reads the whole database as the app's database role, outside the access rules.
+   */
+  mcp?: {
+    sql?: boolean;
+  };
   /**
    * The websites whose browser code may call the API (`/api/*` but `/api/auth/*`) besides the app's own origins (see
    * `createAuth`'s `origins`): a list of origins, or `*` for any. Defaults to the one the platform passes in

package/dist/aggregate-groups.js

@@ -1,7 +1,7 @@
 import { badRequest } from "./problem.js";
-import { readTransaction } from "./transactions.js";
 import { parseParams } from "./params.js";
 import { labelRequests, relatedLabels } from "./related-labels.js";
+import { readTransaction } from "./transactions.js";
 import { splitGroups } from "./aggregate-splits.js";
 import { scoped, seriesRange } from "./aggregate-service.js";
 import { z } from "zod";

package/dist/aggregate-service.js

@@ -1,14 +1,14 @@
 import { badRequest } from "./problem.js";
 import { checkedFilter } from "./filter-input.js";
 import { readScope, requestAccess, requireOperation } from "./request-access.js";
-import { columnId, filterCondition, scopeConditions, tableId, whereClause } from "./sql-parts.js";
-import { readTransaction } from "./transactions.js";
 import { parseParams } from "./params.js";
+import { columnId, filterCondition, scopeConditions, tableId, whereClause } from "./sql-parts.js";
 import { labelRequests, relatedLabels } from "./related-labels.js";
+import { readTransaction } from "./transactions.js";
 import { rangeEnd, rangeStart } from "./range-ends.js";
 import { z } from "zod";
-import { sql } from "kysely";
 import { facetCounts, histogram, series, withoutField } from "@protobase/query";
+import { sql } from "kysely";
 //#region src/aggregate-service.ts
 const field = z.string().min(1);
 const filter = z.string().optional();

package/dist/aggregate-splits.js

@@ -1,5 +1,5 @@
-import { readTransaction } from "./transactions.js";
 import { labelRequests, relatedLabels } from "./related-labels.js";
+import { readTransaction } from "./transactions.js";
 import { series, splitSeries } from "@protobase/query";
 //#region src/aggregate-splits.ts
 /**

package/dist/assistant/built-in-assistant.js

@@ -1,23 +1,14 @@
 import { openRouterUrl } from "./model-settings.js";
 import { seesAssistant } from "./assistant-settings.js";
 import { appContext } from "./app-context.js";
+import { checkedTools } from "./checked-tools.js";
 import { conversationKey, createConversations } from "./conversations.js";
 import { fileConversationStore } from "./file-conversation-store.js";
 import { assistantProtocolRoutes } from "./protocol-routes.js";
 import { readOnlyQueryTool, readWriteQueryTool } from "./query-tools.js";
+import { readableResources } from "./readable-resources.js";
 import { runTurn } from "./turn.js";
 //#region src/assistant/built-in-assistant.ts
-const toolName = /^[A-Za-z0-9_-]{1,64}$/;
-/** The tools in order; a name a model endpoint refuses, or one taken twice, stops the server at startup. */
-const checkedTools = (tools) => {
-	const seen = /* @__PURE__ */ new Set();
-	for (const tool of tools) {
-		if (!toolName.test(tool.name)) throw new Error(`Assistant tool name "${tool.name}" must be 1 to 64 letters, digits, _ or -`);
-		if (seen.has(tool.name)) throw new Error(`Two assistant tools are named "${tool.name}"; give one of them another name`);
-		seen.add(tool.name);
-	}
-	return tools;
-};
 const pageContext = (page) => page && `The user is on the page ${page} of the app (/<resource> lists records, /<resource>/<key> shows one).`;
 /**
 * Protobase's own assistant: answers questions about the app, reads its data with read-only queries and proposes
@@ -47,6 +38,7 @@ const builtInAssistant = ({ model, chats, db, meta, authenticate, tools: appTool
 				system: appContext(body.resources, body.views),
 				tools,
 				...records && { records: records(session) },
+				resources: () => readableResources(meta, session),
 				report,
 				...page && { context: pageContext(page) },
 				...onOpenRouter && {

package/dist/assistant/checked-tools.js

@@ -0,0 +1,14 @@
+//#region src/assistant/checked-tools.ts
+const toolName = /^[A-Za-z0-9_-]{1,64}$/;
+/** The tools in order; a name a model endpoint refuses, or one taken twice, stops the server at startup. */
+const checkedTools = (tools) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const tool of tools) {
+		if (!toolName.test(tool.name)) throw new Error(`Assistant tool name "${tool.name}" must be 1 to 64 letters, digits, _ or -`);
+		if (seen.has(tool.name)) throw new Error(`Two assistant tools are named "${tool.name}"; give one of them another name`);
+		seen.add(tool.name);
+	}
+	return tools;
+};
+//#endregion
+export { checkedTools };

package/dist/assistant/query-tools.js

@@ -36,6 +36,10 @@ const readOnlyQueryTool = (db, options = {}) => defineTool({
 		properties: { sql: sqlParameter("One SELECT statement, without a trailing semicolon.") },
 		required: ["sql"]
 	},
+	annotations: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
 	run: async (args, context) => {
 		const statement = statementOf(args);
 		if (!statement) return "Pass the statement as { \"sql\": \"select ...\" }.";
@@ -60,6 +64,11 @@ const readWriteQueryTool = (db, options = {}) => defineTool({
 		},
 		required: ["sql", "summary"]
 	},
+	annotations: {
+		readOnlyHint: false,
+		destructiveHint: true,
+		openWorldHint: false
+	},
 	run: async (args, context) => {
 		const statement = statementOf(args);
 		if (!statement) return "Pass the statement as { \"sql\": \"update ... returning ...\", \"summary\": \"...\" }.";

package/dist/assistant/readable-resources.d.ts

@@ -0,0 +1,7 @@
+import { Session } from "../types.js";
+import { ReadableResources } from "./tools.js";
+import { Meta } from "../meta.js";
+//#region src/assistant/readable-resources.d.ts
+/** The resources `session` may read or list, leaving out those it may only create in, with their views. */
+export declare const readableResources: (meta: Pick<Meta, "forCaller">, session: Session) => Promise<ReadableResources>;
+//#endregion

package/dist/assistant/readable-resources.js

@@ -0,0 +1,13 @@
+//#region src/assistant/readable-resources.ts
+/** The resources `session` may read or list, leaving out those it may only create in, with their views. */
+const readableResources = async (meta, session) => {
+	const { body } = await meta.forCaller(session);
+	const models = body.resources.filter((model) => body.permissions[model.name]?.read);
+	const names = new Set(models.map((model) => model.name));
+	return {
+		models,
+		views: body.views.filter((view) => names.has(view.resource))
+	};
+};
+//#endregion
+export { readableResources };

package/dist/assistant/record-tools.d.ts

@@ -0,0 +1,11 @@
+import { AssistantTool } from "./tools.js";
+//#region src/assistant/record-tools.d.ts
+/** Lists the resources the caller may read, with their fields, labels and which fields filters and sorts take. */
+export declare const listResourcesTool: () => AssistantTool;
+/** Finds records of a resource with the REST API's filters, sorting and pages, under the caller's access rules. */
+export declare const listRecordsTool: () => AssistantTool;
+/** Reads one record by its key, under the caller's access rules. */
+export declare const getRecordTool: () => AssistantTool;
+/** `list_resources`, `list_records` and `get_record`: reading the app's records as the caller, through the REST API's rules. */
+export declare const readRecordTools: () => AssistantTool[];
+//#endregion

package/dist/assistant/record-tools.js

@@ -0,0 +1,140 @@
+import { HttpProblem } from "../problem.js";
+import { defineTool } from "./tools.js";
+//#region src/assistant/record-tools.ts
+const readOnly = {
+	readOnlyHint: true,
+	openWorldHint: false
+};
+const defaultPageSize = 20;
+const maxPageSize = 100;
+const refused = (error) => {
+	if (error instanceof HttpProblem && error.status < 500) return JSON.stringify({
+		error: error.slug,
+		message: error.detail
+	});
+	throw error;
+};
+const fieldEntry = (field, view) => {
+	const hint = view?.fields[field.name];
+	return {
+		name: field.name,
+		type: field.type,
+		...hint?.label && { label: hint.label },
+		...hint?.help && { help: hint.help },
+		...field.enumValues && { values: field.enumValues },
+		...field.relation && { links_to: field.relation.resource },
+		optional: field.nullable,
+		read_only: field.readOnly,
+		filterable: field.filterable,
+		sortable: field.sortable
+	};
+};
+const resourceEntry = (model, view) => ({
+	name: model.name,
+	...view?.names && { label: view.names.plural },
+	...view?.help && { help: view.help },
+	key: model.primaryKey,
+	fields: Object.values(model.fields).map((field) => fieldEntry(field, view))
+});
+const described = ({ models, views }) => models.map((model) => resourceEntry(model, views.find((view) => view.resource === model.name)));
+const resourceOf = (args) => typeof args.resource === "string" && args.resource ? args.resource : void 0;
+const keyOf = (value) => {
+	if (typeof value === "string" || typeof value === "number") return value;
+	if (Array.isArray(value) && value.length > 0 && value.every((part) => typeof part === "string" || typeof part === "number")) return value;
+};
+const resourceParameter = {
+	type: "string",
+	description: "The resource's name, as list_resources gives it."
+};
+/** Lists the resources the caller may read, with their fields, labels and which fields filters and sorts take. */
+const listResourcesTool = () => defineTool({
+	name: "list_resources",
+	description: "Lists the resources you may read, as JSON: each with its name, label, key fields and fields (name, type, label, enum values, the resource a relation links to, and whether it is optional, read-only, filterable and sortable). Filters and order_by in list_records take only fields marked filterable or sortable.",
+	parameters: {
+		type: "object",
+		properties: {}
+	},
+	annotations: readOnly,
+	run: async (_args, context) => JSON.stringify(described(await context.resources()))
+});
+/** Finds records of a resource with the REST API's filters, sorting and pages, under the caller's access rules. */
+const listRecordsTool = () => defineTool({
+	name: "list_records",
+	description: `Finds records of a resource and returns a page of them as JSON ({ items, next_page_token, total_size_estimate }). filter uses AIP-160 syntax, such as status = "open" AND amount > 10, and order_by a comma-separated list of fields, each optionally followed by desc. Pass next_page_token back as page_token for the next page; it is empty on the last.`,
+	parameters: {
+		type: "object",
+		properties: {
+			resource: resourceParameter,
+			filter: {
+				type: "string",
+				description: "An AIP-160 filter on filterable fields, such as status = \"open\" AND amount > 10."
+			},
+			order_by: {
+				type: "string",
+				description: "Sortable fields, comma-separated, each optionally followed by desc, such as created_at desc."
+			},
+			page_size: {
+				type: "integer",
+				minimum: 1,
+				maximum: maxPageSize,
+				description: `Records per page, ${defaultPageSize} by default.`
+			},
+			page_token: {
+				type: "string",
+				description: "The next_page_token of the previous page."
+			}
+		},
+		required: ["resource"]
+	},
+	annotations: readOnly,
+	run: async (args, context) => {
+		const resource = resourceOf(args);
+		if (!resource) return "Pass the resource as { \"resource\": \"<name>\" }.";
+		const params = {
+			...typeof args.filter === "string" && { filter: args.filter },
+			...typeof args.order_by === "string" && { order_by: args.order_by },
+			...typeof args.page_token === "string" && { page_token: args.page_token },
+			page_size: typeof args.page_size === "number" ? Math.min(args.page_size, maxPageSize) : defaultPageSize
+		};
+		return context.records.list(resource, params).then((page) => JSON.stringify(page), refused);
+	}
+});
+/** Reads one record by its key, under the caller's access rules. */
+const getRecordTool = () => defineTool({
+	name: "get_record",
+	description: "Reads one record of a resource by its key and returns it as JSON ({ record, etag }).",
+	parameters: {
+		type: "object",
+		properties: {
+			resource: resourceParameter,
+			key: {
+				description: "The record's key: its value, or the values of its key fields in order when the key has several.",
+				anyOf: [
+					{ type: "string" },
+					{ type: "number" },
+					{
+						type: "array",
+						items: { type: ["string", "number"] },
+						minItems: 1
+					}
+				]
+			}
+		},
+		required: ["resource", "key"]
+	},
+	annotations: readOnly,
+	run: async (args, context) => {
+		const resource = resourceOf(args);
+		const key = keyOf(args.key);
+		if (!resource || key === void 0) return "Pass the resource and key as { \"resource\": \"<name>\", \"key\": \"<key>\" }.";
+		return context.records.get(resource, key).then((record) => JSON.stringify(record), refused);
+	}
+});
+/** `list_resources`, `list_records` and `get_record`: reading the app's records as the caller, through the REST API's rules. */
+const readRecordTools = () => [
+	listResourcesTool(),
+	listRecordsTool(),
+	getRecordTool()
+];
+//#endregion
+export { getRecordTool, listRecordsTool, listResourcesTool, readRecordTools };

package/dist/assistant/records.d.ts

@@ -8,11 +8,38 @@ export type ToolRecord = {
   record: Row;
   etag: string;
 };
+/** The list parameters of the REST API (AIP-132), as values rather than query text. */
+export type ListParams = {
+  filter?: string;
+  order_by?: string;
+  page_size?: number;
+  page_token?: string;
+  fields?: string[];
+  count?: 'exact';
+  show_deleted?: boolean;
+};
+/**
+ * A page of records as the REST API lists it: each item with its `etag` and, unless the resource opts out, whether the
+ * caller may update and delete it; and the token of the next page, empty on the last.
+ */
+export type RecordPage = {
+  items: Array<Row & {
+    etag?: string;
+    permissions?: {
+      update: boolean;
+      delete: boolean;
+    };
+  }>;
+  next_page_token: string;
+  total_size_estimate: number;
+  total_size?: number;
+};
 /**
  * The app's resources as the session's user: their access rules, tenant scope, validation and write hooks apply as
  * in the REST API. A refusal or a missing record rejects with an `HttpProblem`, which a tool can turn into text.
  */
 export type ToolRecords = {
+  list: (resource: string, params?: ListParams) => Promise<RecordPage>;
   get: (resource: string, key: RecordKeyInput) => Promise<ToolRecord>;
   create: (resource: string, data: Row) => Promise<ToolRecord>;
   /** With `etag`, fails with 412 when the record changed since it was read; without, it updates any version. */

package/dist/assistant/records.js

@@ -1,9 +1,11 @@
 import { notFound } from "../problem.js";
 import { decodeKeyText } from "../key.js";
+import { listRecords } from "../list-service.js";
 import { readRecord } from "../read-service.js";
 import { runWrite } from "../write-pipeline.js";
 import { encodeKey } from "@protobase/schema/internal";
 //#region src/assistant/records.ts
+const filterLength = 2e5;
 /** `ToolRecords` over the admin's resources for `session`. */
 const assistantRecords = (deps, session) => {
 	const entryOf = (resource) => {
@@ -19,6 +21,7 @@ const assistantRecords = (deps, session) => {
 		};
 	};
 	return {
+		list: async (resource, params = {}) => (await listRecords(deps, entryOf(resource), session, params, filterLength)).body,
 		get: async (resource, input) => {
 			const { entry, key } = keyOf(resource, input);
 			const { record, etag } = await readRecord(deps, entry, session, key);
@@ -45,6 +48,7 @@ const assistantRecords = (deps, session) => {
 const withoutAdmin = () => Promise.reject(/* @__PURE__ */ new Error("This assistant has no records: ToolContext.records works in the built-in assistant"));
 /** Records for a turn without an admin around it, such as in a backend of its own: every call fails. */
 const noRecords = {
+	list: withoutAdmin,
 	get: withoutAdmin,
 	create: withoutAdmin,
 	update: withoutAdmin

package/dist/assistant/tools.d.ts

@@ -2,17 +2,33 @@ import { Session } from "../types.js";
 import { ToolRecords } from "./records.js";
 import { Conversation } from "./conversations.js";
 import { ApprovalAnswer, ApprovalRequest } from "./approval.js";
-import { AssistantPart } from "@protobase/schema";
+import { AssistantPart, ResourceModel, ViewModel } from "@protobase/schema";
 //#region src/assistant/tools.d.ts
+/** The resources a caller may read, each restricted to their fields, with their views. */
+export type ReadableResources = {
+  models: ResourceModel[];
+  views: ViewModel[];
+};
 export type ToolContext = {
   session: Session;
-  conversation: Conversation;
+  /** The dock's conversation; absent over MCP. */
+  conversation?: Conversation;
   /** Adds a part, such as a table of results, to the assistant message the turn is writing. */
   show: (part: AssistantPart) => void;
   /** Asks the user to approve with a card in that message (see `requestApproval`). */
   approve: (request: ApprovalRequest) => Promise<ApprovalAnswer>;
   /** The app's resources as the session's user, through their access rules and write hooks (built-in assistant only). */
   records: ToolRecords;
+  /** The resources the caller may read, each restricted to their fields, with their views. */
+  resources: () => Promise<ReadableResources>;
+};
+/** MCP's tool hints, which an MCP client may show or act on; the dock ignores them. */
+export type ToolAnnotations = {
+  title?: string;
+  readOnlyHint?: boolean;
+  destructiveHint?: boolean;
+  idempotentHint?: boolean;
+  openWorldHint?: boolean;
 };
 /**
  * A function the model may call during a turn. `parameters` is the JSON Schema of its arguments; `run` gets them
@@ -23,6 +39,7 @@ export type AssistantTool = {
   description: string;
   parameters: Record<string, unknown>;
   run: (args: Record<string, unknown>, context: ToolContext) => Promise<string>;
+  annotations?: ToolAnnotations;
 };
 /** Typed identity, for a tool of your own. */
 export declare const defineTool: (tool: AssistantTool) => AssistantTool;

package/dist/assistant/turn.d.ts

@@ -2,7 +2,7 @@ import { Session } from "../types.js";
 import { ModelSettings, ReasoningEffort } from "./chat-completions.js";
 import { ToolRecords } from "./records.js";
 import { Conversation } from "./conversations.js";
-import { AssistantTool } from "./tools.js";
+import { AssistantTool, ReadableResources } from "./tools.js";
 //#region src/assistant/turn.d.ts
 export type TurnOptions = {
   model: ModelSettings;
@@ -13,6 +13,8 @@ export type TurnOptions = {
   tools?: AssistantTool[];
   /** What tools get as `records`; without it, their calls fail. */
   records?: ToolRecords;
+  /** What tools get as `resources`; without it, no resources. */
+  resources?: () => Promise<ReadableResources>;
   /** Model calls in one turn before it stops. Default 8. */
   maxSteps?: number;
   /** Gets errors other than the model endpoint's refusals, which the user only sees as a failure. */

package/dist/assistant/turn.js

@@ -3,6 +3,10 @@ import { ModelError, streamChatCompletion } from "./chat-completions.js";
 import { requestApproval } from "./approval.js";
 import { withCacheBreakpoints } from "./cache-breakpoints.js";
 //#region src/assistant/turn.ts
+const noResources = async () => ({
+	models: [],
+	views: []
+});
 const toolResult = async (call, tools, context) => {
 	const tool = tools.find((entry) => entry.name === call.function.name);
 	if (!tool) return `There is no tool named "${call.function.name}".`;
@@ -41,7 +45,8 @@ const runTurn = async (options, text) => {
 		conversation,
 		show,
 		approve: (request) => requestApproval(conversation, messageId, request),
-		records: options.records ?? noRecords
+		records: options.records ?? noRecords,
+		resources: options.resources ?? noResources
 	};
 	const specs = tools.map((tool) => ({
 		type: "function",

package/dist/comments/mention-job.d.ts

@@ -1,3 +1,16 @@
-import "./comment-users.js";
+import { JobDefinition } from "../jobs/job-types.js";
+import { CommentUsers } from "./comment-users.js";
 import "../index.js";
-import { z } from "zod";
+import { z } from "zod";
+//#region src/comments/mention-job.d.ts
+/**
+ * The job that emails someone a comment mentions, enqueued with the comment: nothing when the app has no mail, when an
+ * admin deleted the comment since, or when the user is banned or gone. A refused send is retried.
+ */
+export declare const mentionJob: (users: CommentUsers | undefined, appName: string) => JobDefinition<{
+  comment: string;
+  user: string;
+  url: string;
+  record: string;
+}>;
+//#endregion

package/dist/comments/mentionable.js

@@ -1,6 +1,6 @@
 import { notFound } from "../problem.js";
-import { readTransaction } from "../transactions.js";
 import { parseParams } from "../params.js";
+import { readTransaction } from "../transactions.js";
 import { commentAccess, mayRead, readableRecord, requireSignedIn, userSessions } from "./comment-access.js";
 import { z } from "zod";
 //#region src/comments/mentionable.ts

package/dist/comments/read-comments.js

@@ -1,8 +1,8 @@
 import { notFound } from "../problem.js";
 import { tenantScope } from "../tenant.js";
+import { parseParams } from "../params.js";
 import { readTransaction } from "../transactions.js";
 import { commentsTable } from "./comments-sql.js";
-import { parseParams } from "../params.js";
 import { commentAccess, readableRecord } from "./comment-access.js";
 import { commentColumns, commentItem, namedUsers } from "./comment-item.js";
 import { encodeKey } from "@protobase/schema/internal";

package/dist/create-admin.js

@@ -23,6 +23,12 @@ import { realtimePath, restPath, storagePath, supabaseFunctionsPath, supabasePat
 import { goTruePath } from "./gotrue/keys.js";
 import { authBasePath } from "./better-auth/auth-base-path.js";
 import { mcpDiscovery } from "./better-auth/mcp/discovery-routes.js";
+import { mcpAuthenticator } from "./mcp/mcp-authenticator.js";
+import { mcpToolContext } from "./mcp/mcp-context.js";
+import { mcpHandler } from "./mcp/mcp-handler.js";
+import { mcpRoutes } from "./mcp/mcp-routes.js";
+import { mcpServer } from "./mcp/mcp-server.js";
+import { mcpTools } from "./mcp/mcp-tools.js";
 import { withoutSessionTokens } from "./better-auth/without-session-tokens.js";
 import { organizationRoutes } from "./better-auth/organizations/admin-routes.js";
 import { statusRoute } from "./better-auth/status-route.js";
@@ -120,6 +126,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 	checkViews(registry, viewModels, pageModels.map((entry) => entry.name), fieldTypes);
 	checkRoleLimits(registry, options.roles?.limits ?? []);
 	checkOwnerFields(registry, authenticate.userIdType, auth);
+	const mcpAuthenticate = mcpAuthenticator(authenticate, auth?.mcp, options.mcp);
 	checkPositionAfter(registry);
 	checkParents(registry);
 	checkPages(pageModels, {
@@ -241,7 +248,11 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 	const corsOrigins = withMobileOrigins(options.cors ?? readCorsOrigins(globalThis.process?.env ?? {}), Boolean(mobile));
 	const ownOrigins = auth?.origins ?? [];
 	if (corsOrigins !== void 0 || ownOrigins.length > 1) {
-		const answering = [authBasePath, ...Object.entries(apiFunctions).filter(([, fn]) => fn.options.cors).flatMap(([name]) => [`${systemPath}/functions/${name}`, `${supabaseFunctionsPath}/${name}`])];
+		const answering = [
+			authBasePath,
+			...auth?.mcp ? [auth.mcp.path] : [],
+			...Object.entries(apiFunctions).filter(([, fn]) => fn.options.cors).flatMap(([name]) => [`${systemPath}/functions/${name}`, `${supabaseFunctionsPath}/${name}`])
+		];
 		const skip = (path) => answering.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
 		const cors = apiCors({
 			own: ownOrigins,
@@ -283,6 +294,30 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 		}));
 	}
 	const report = options.onUnhandledError ?? ((error) => console.error(error));
+	if (auth?.mcp && mcpAuthenticate) {
+		const tools = mcpTools({
+			db,
+			sql: options.mcp?.sql === true
+		});
+		const server = (session) => mcpServer({
+			info: {
+				name: appName,
+				version: "1.0.0"
+			},
+			tools: tools(session),
+			context: mcpToolContext(deps, meta, session),
+			report
+		});
+		mcpRoutes(app, {
+			path: auth.mcp.path,
+			handler: mcpHandler({
+				authenticate: mcpAuthenticate,
+				resource: auth.mcp.resource,
+				scope: auth.mcp.scope,
+				server
+			})
+		});
+	}
 	const upgradeAuthenticate = upgradeAuthenticator({
 		authenticate,
 		...auth && {

package/dist/deps.d.ts

@@ -1,12 +1,81 @@
-import "./types.js";
-import "./comments/comment-users.js";
-import "./comments/mention-job.js";
-import "./encryption/runtime.js";
-import "./files/runtime.js";
-import "./plugins/plugin-settings.js";
-import "./registry.js";
-import "./scan-guard.js";
+import { AuditQueue, PipelineHook } from "./types.js";
+import { CommentUsers } from "./comments/comment-users.js";
+import { ErrorReportingSettings } from "./error-reporting/error-reporting-settings.js";
+import { mentionJob } from "./comments/mention-job.js";
+import { ModelSettings } from "./assistant/chat-completions.js";
+import { EncryptionRuntime } from "./encryption/runtime.js";
+import { FilesRuntime } from "./files/runtime.js";
+import { MapSettings } from "./maps/map-settings.js";
+import { PluginOption } from "./plugins/plugin-settings.js";
+import { Registry } from "./registry.js";
+import { SourceOption } from "./sources/source-settings.js";
+import { ScanGuard } from "./scan-guard.js";
 import { PageModel } from "@protobase/layout";
 import { Locale } from "@protobase/schema/internal";
-import { ResolveOptions, ViewModel } from "@protobase/schema";
-import { Db } from "@protobase/query";
+import { BottomBarModel, ResolveOptions, UserMenuModel, ViewModel } from "@protobase/schema";
+import { Db } from "@protobase/query";
+//#region src/deps.d.ts
+/** Everything a route needs, built once by `createAdmin` and passed down explicitly. */
+export type Deps = {
+  db: Db;
+  registry: Registry;
+  views: ViewModel[];
+  userMenu?: UserMenuModel;
+  /** The bottom bars, in config order. */
+  bottomBars: BottomBarModel[];
+  pages: PageModel[];
+  basePath: string;
+  /** Where the system endpoints live (`/meta`, `/openapi.json`, `/docs`): the parent of `basePath`, `/api` by default. */
+  systemPath: string;
+  statementTimeoutMs: number;
+  guard: ScanGuard;
+  hooks: readonly PipelineHook[];
+  accessOptions: ResolveOptions;
+  /** Where reveals of sensitive fields are published. */
+  audit: AuditQueue;
+  /** Whether list items of a resource carry their permissions. */
+  rowPermissions: (resource: string) => boolean;
+  /** The URL of the assistant backend that `/meta` names to callers who may use it: another origin's, or the built-in one's path. */
+  assistant?: string;
+  /** The URL of the runtime updates endpoint that `/meta` names to admins. */
+  runtime?: string;
+  /** Where the admin app sends its errors, which `/meta` names to everyone. */
+  errorReporting?: ErrorReportingSettings;
+  /** The map style the admin app draws maps with and the layers they may switch to, which `/meta` names to everyone. */
+  maps?: MapSettings;
+  /** The language the admin app's screens are in for everyone, which `/meta` names to everyone. */
+  locale?: Locale;
+  /** The plugins `/meta` names to the callers they are for. */
+  plugins: PluginOption[];
+  /** The other APIs whose resources `/meta` names to the callers they are for. */
+  sources: SourceOption[];
+  /** Providers, signing and scheduled deletes, when a resource has a file field. */
+  files?: FilesRuntime;
+  /** The keys encrypted fields are sealed and revealed with, when a resource has one. */
+  encryption?: EncryptionRuntime;
+  /** The transaction setting that tells the change capture who writes, when a resource has events or history (`changes.actor`). */
+  actorSetting?: string;
+  /** Where record history is kept, when a resource has `.history()`, and the names of the users who made changes. */
+  history?: {
+    schema: string;
+    actorNames?: (ids: readonly string[]) => Promise<Record<string, string>>;
+  };
+  /**
+   * When a resource has `.comments()`: with the project's auth, its users and the job that mails a mention; and the
+   * origin of the app for a request's URL, which the mailed links go to.
+   */
+  comments?: {
+    users?: CommentUsers;
+    mentionJob?: ReturnType<typeof mentionJob>;
+    appOrigin: (requestURL: string) => string;
+  };
+  /**
+   * When a resource has an AI field or a view an AI action: the model they call (none without a key), and where a model
+   * that fails an action is reported.
+   */
+  ai?: {
+    model?: ModelSettings;
+    report?: (error: unknown) => void;
+  };
+};
+//#endregion