@softure-ai/mcp-access 0.2.5 → 0.2.8

package/dist/testing/catalog.js.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../src/testing/catalog.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../src/testing/catalog.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAA4B,MAAM,wBAAwB,CAAC;AAiBrG,MAAM,MAAM,GAAsB,EAAE,MAAM,EAAE,sCAAsC,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC;AAChI,MAAM,MAAM,GAAsB,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAEhE,2HAA2H;AAC3H,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,MAAqB,EAAE,YAA8B;IACnG,MAAM,OAAO,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC;IAClD,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC/D,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC/D,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACzD,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;QACzL,QAAQ,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,UAAU,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1F,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,OAAO,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;KAC9H,CAAC;AACJ,CAAC;AAED,iFAAiF;AACjF,MAAM,CAAC,KAAK,UAAU,8BAA8B,CAAC,MAAqB,EAAE,YAA8B;IACxG,MAAM,WAAW,GAAG,MAAM,yBAAyB,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC1E,MAAM,QAAQ,GAAG;QACf,WAAW,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,4BAA4B,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI;QACpG,WAAW,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,sCAAsC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI;QAChH,WAAW,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,uCAAuC,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI;KAChI,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC;IACxC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,gGAAgG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACzI,CAAC;AACH,CAAC;AAED,kGAAkG;AAClG,KAAK,UAAU,eAAe,CAAC,YAA8B,EAAE,QAA2B;IACxF,OAAO,CAAC,MAAM,eAAe,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACxF,CAAC;AAED,0HAA0H;AAC1H,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,YAA8B,EAAE,OAAgB;IAC3F,OAAO;QACL,IAAI,EAAE,gBAAgB,CAAC,MAAM,eAAe,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC;QAClF,KAAK,EAAE,gBAAgB,CAAC,MAAM,eAAe,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC;KACpF,CAAC;AACJ,CAAC"}

package/dist/testing/index.d.ts

@@ -1,2 +1,2 @@
-export { expectToolCatalogMatchesServer, getToolCatalogDifferences, type ToolCatalogDifferences } from "./catalog.js";
+export { expectToolCatalogMatchesServer, getToolCatalogDifferences, measureServedToolLists, type ServedToolLists, type ToolCatalogDifferences, } from "./catalog.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,yBAAyB,EAAE,KAAK,sBAAsB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,8BAA8B,EAC9B,yBAAyB,EACzB,sBAAsB,EACtB,KAAK,eAAe,EACpB,KAAK,sBAAsB,GAC5B,MAAM,cAAc,CAAC"}

package/dist/testing/index.js

@@ -1,3 +1,3 @@
 // `@softure-ai/mcp-access/testing`: checks for an app's own tests.
-export { expectToolCatalogMatchesServer, getToolCatalogDifferences } from "./catalog.js";
+export { expectToolCatalogMatchesServer, getToolCatalogDifferences, measureServedToolLists, } from "./catalog.js";
 //# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,OAAO,EAAE,8BAA8B,EAAE,yBAAyB,EAA+B,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,OAAO,EACL,8BAA8B,EAC9B,yBAAyB,EACzB,sBAAsB,GAGvB,MAAM,cAAc,CAAC"}

package/module.json

@@ -1,6 +1,6 @@
 {
   "id": "mcp-access",
-  "version": "0.2.5",
+  "version": "0.2.8",
   "dependsOn": { "security": "^0.2.0", "auth": "^0.2.0", "jobs": "^0.1.1?", "ops": "^0.2.0?" },
   "dbSchema": "mcp",
   "tables": ["access_tokens", "oauth_clients", "oauth_authorization_codes", "oauth_grants", "oauth_registration_window"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softure-ai/mcp-access",
-  "version": "0.2.5",
+  "version": "0.2.8",
   "description": "SOFTURE AI MCP access module: hashed, scoped, expiring access tokens, a rate-limited Bearer endpoint around the app's MCP server factory, and a token page with client setup instructions for Next.js; tool result helpers with a safe error boundary, a stdio entry, a catalog parity check and the softure-mcp prune command.",
   "license": "MIT",
   "type": "module",

package/src/index.ts

@@ -34,7 +34,7 @@ export const MCP_RATE_LIMIT_BUCKETS = {
 export const mcpAccess = defineModule({
   manifest: {
     id: MODULE_ID,
-    version: "0.2.5",
+    version: "0.2.8",
     dependsOn: { security: "^0.2.0", auth: "^0.2.0", jobs: "^0.1.1?", ops: "^0.2.0?" },
     dbSchema: "mcp",
     tables: ["access_tokens", "oauth_clients", "oauth_authorization_codes", "oauth_grants", "oauth_registration_window"],

package/src/messages/en.ts

@@ -85,6 +85,15 @@ export const en = {
     nothingGranted: "No access was granted.",
     backToApp: "Back to the app ({target})",
   },
+  toolInput: {
+    unknownFields: "Unknown fields: {fields}. Accepted fields: {accepted}.",
+    noFields: "none",
+    fieldRenamed: "input.field_renamed: the field \"{field}\" is now \"{renamed}\". Send it as \"{renamed}\".",
+  },
+  serverInfoTool: {
+    description:
+      "Tells which build of this server answers: its name and version (the version changes whenever a tool changes), the release, the commit, when it was built and started, and the changelog when the app publishes one. Use it to check that a change is live.",
+  },
   errors: {
     "mcp-access": {
       name_required: "Give the token a name, so you can tell it from the others.",

package/src/server/action-tool.ts

@@ -1,7 +1,7 @@
 // A server action as a write tool: the tool's arguments become the form the action reads, so the tool
 // and the form share one validation path, and the action's error state becomes a tool error.
 import type { CallToolResult } from "@modelcontextprotocol/server";
-import { describeCode, toolError, toolResult, withToolErrors, type ToolErrorHints } from "./tools.js";
+import { toolResult, withToolErrors, type ToolCaller, type ToolCallHook, type ToolErrorHints } from "./tools.js";
 
 /** The action, called with the form. A `useActionState` action is passed as `(form) => action(INITIAL, form)`. */
 export type FormActionHandler = (formData: FormData) => unknown;
@@ -11,8 +11,12 @@ export interface ActionToolOptions {
   readonly message?: string | ((state: unknown) => string);
   /** Texts per error code, as in `withToolErrors`. */
   readonly hints?: ToolErrorHints;
-  /** The tool's name in the log line. */
+  /** The tool's name in the log line and in the `onToolCall` record. */
   readonly label?: string;
+  /** Called once after each call with its record, as in `withToolErrors`. */
+  readonly onToolCall?: ToolCallHook;
+  /** Who called, for the record, as in `withToolErrors`. */
+  readonly caller?: ToolCaller;
 }
 
 /** The tool callback for `server.registerTool(name, { inputSchema }, actionTool(handler))`. */
@@ -23,11 +27,18 @@ export function actionTool(handler: FormActionHandler, options: ActionToolOption
       async () => {
         const state = await handler(toFormData(args));
         const error = readErrorCode(state);
-        if (error !== null) return toolError(describeCode(error, hints));
+        // As a core result, so withToolErrors answers it through the hints and records its code.
+        if (error !== null) return { ok: false, error };
         if (options.message === undefined) return toolResult(state);
         return toolResult(typeof options.message === "string" ? options.message : options.message(state));
       },
-      { hints, ...(options.label === undefined ? {} : { label: options.label }) },
+      {
+        hints,
+        args,
+        ...(options.label === undefined ? {} : { label: options.label }),
+        ...(options.onToolCall === undefined ? {} : { onToolCall: options.onToolCall }),
+        ...(options.caller === undefined ? {} : { caller: options.caller }),
+      },
     );
 }
 

package/src/server/index.ts

@@ -92,6 +92,7 @@ export {
   issueAccessToken,
   listAccessTokens,
   pruneAccessTokens,
+  findTokenClientName,
   revokeAccessToken,
   verifyAccessToken,
   type IssueAccessTokenInput,
@@ -101,4 +102,36 @@ export {
   type RevokeAccessTokenInput,
   type VerifiedAccessToken,
 } from "./tokens.js";
-export { toolError, toolResult, withToolErrors, type ToolErrorHints, type ToolErrorOptions } from "./tools.js";
+export { createMcpServerFactory, type McpServerFactoryOptions } from "./server-factory.js";
+export {
+  registerServerInfoTool,
+  SERVER_INFO_TOOL_NAME,
+  type McpBuildInfo,
+  type RegisterServerInfoToolOptions,
+  type ServedServerInfo,
+  type ServerInfoAnswer,
+  type ServerInfoToolOptions,
+} from "./server-info.js";
+export { toStrictToolInput, withStrictToolInput, type StrictToolInputMessages, type StrictToolInputOptions } from "./strict-input.js";
+export {
+  DEFAULT_TOOL_LIST_RELEASE,
+  describeToolList,
+  fingerprintToolList,
+  listServedTools,
+  measureToolList,
+  type MeasureToolListOptions,
+  type RegisterTools,
+  type ServedTool,
+  type ToolListMeasurement,
+} from "./tool-list.js";
+export {
+  toolError,
+  toolResult,
+  withToolErrors,
+  type ToolCaller,
+  type ToolCallHook,
+  type ToolCallOutcome,
+  type ToolCallRecord,
+  type ToolErrorHints,
+  type ToolErrorOptions,
+} from "./tools.js";

package/src/server/server-factory.ts

@@ -0,0 +1,78 @@
+// The app's MCP server factory with a version that follows its tool list. The tools are measured once
+// per access level (a read-only token sees fewer tools) on a recording server, and each request's
+// server answers `initialize` with that level's version, so a client drops its cached `tools/list`
+// whenever a release changes a tool. The factory plugs into `createMcpEndpoint`, `serveMcpStdio` and
+// the catalog check like a hand-written one.
+//
+//   export const createServer = createMcpServerFactory({
+//     name: "acme",
+//     registerTools: (server, identity) => registerNoteTools(server, identity),
+//   });
+import { McpServer, type McpServerOptions } from "@modelcontextprotocol/server";
+import type { McpServerIdentity } from "../contract.js";
+import type { McpServerFactory } from "./endpoint.js";
+import { withStrictToolInput, type StrictToolInputOptions } from "./strict-input.js";
+import { registerServerInfoTool, type ServerInfoToolOptions } from "./server-info.js";
+import { measureToolList, type ToolListMeasurement } from "./tool-list.js";
+
+export interface McpServerFactoryOptions {
+  /** `serverInfo.name`. */
+  readonly name: string;
+  /** `serverInfo.title`, the name a client shows. */
+  readonly title?: string;
+  /** The `MAJOR.MINOR.PATCH` before `-tools-`. Default: `1.0.0`. */
+  readonly release?: string;
+  /** A fixed `serverInfo.version` instead of the measured one. */
+  readonly version?: string;
+  readonly serverOptions?: McpServerOptions;
+  /**
+   * Registers the tools for one request. The tool list may depend on `identity.canWrite` only: it is
+   * measured once per access level. A list that depends on the account needs `measureToolList` per call.
+   */
+  readonly registerTools: (server: McpServer, identity: McpServerIdentity) => unknown;
+  /** Every tool's input is strict (`withStrictToolInput`), on the served and the measured server alike. */
+  readonly strictToolInput?: boolean | StrictToolInputOptions;
+  /**
+   * Adds the read-only `get_server_info` tool for every access level: the build info (pass `readBuildInfo` of
+   * `@softure-ai/ops/server`) with the served name and version. Off by default.
+   */
+  readonly serverInfoTool?: ServerInfoToolOptions;
+}
+
+/** An `McpServerFactory` whose servers carry the tool list's version for the identity's access level. */
+export function createMcpServerFactory(options: McpServerFactoryOptions): McpServerFactory {
+  const strictOptions = options.strictToolInput === true ? {} : options.strictToolInput === false ? undefined : options.strictToolInput;
+  // The served version reaches `get_server_info` here; the recording server registers it with a placeholder, since
+  // its handler never runs there and the version is not part of the listed tool.
+  const registerTools = async (server: McpServer, identity: McpServerIdentity, version = ""): Promise<void> => {
+    const target = strictOptions === undefined ? server : withStrictToolInput(server, strictOptions);
+    await options.registerTools(target, identity);
+    if (options.serverInfoTool !== undefined) registerServerInfoTool(target, { ...options.serverInfoTool, server: { name: options.name, version } });
+  };
+  const measurements = new Map<boolean, Promise<ToolListMeasurement>>();
+
+  // The promise is cached, so parallel first requests measure once; a failed measurement is dropped so
+  // the next request tries again instead of failing for good.
+  const measure = (identity: McpServerIdentity): Promise<ToolListMeasurement> => {
+    const cached = measurements.get(identity.canWrite);
+    if (cached !== undefined) return cached;
+    const measurement = measureToolList((server) => registerTools(server, identity), {
+      ...(options.release === undefined ? {} : { release: options.release }),
+      name: options.name,
+      ...(options.serverOptions === undefined ? {} : { serverOptions: options.serverOptions }),
+    });
+    measurements.set(identity.canWrite, measurement);
+    void measurement.catch(() => measurements.delete(identity.canWrite));
+    return measurement;
+  };
+
+  return async (identity) => {
+    const version = options.version ?? (await measure(identity)).toolListVersion;
+    const server = new McpServer(
+      { name: options.name, version, ...(options.title === undefined ? {} : { title: options.title }) },
+      options.serverOptions,
+    );
+    await registerTools(server, identity, version);
+    return server;
+  };
+}

package/src/server/server-info.ts

@@ -0,0 +1,76 @@
+// The `get_server_info` tool (#885): an assistant checks a "done" against production in one call. It answers the
+// public facts of the ops build info route (release, commit, build and start times, the optional changelog) and the
+// name and version the server answered at `initialize`, which follows the tool list. It reads no user data.
+//
+// The app passes the build info reader, so `/server` never loads `@softure-ai/ops` (an optional peer):
+//
+//   import { readBuildInfo } from "@softure-ai/ops/server";
+//   createMcpServerFactory({ name: "acme", registerTools, serverInfoTool: { buildInfo: () => readBuildInfo() } });
+import type { McpServer } from "@modelcontextprotocol/server";
+import { errorLogLabel } from "@softure-ai/core";
+import { z } from "zod";
+import { en } from "../messages/en.js";
+import { toolResult } from "./tools.js";
+
+export const SERVER_INFO_TOOL_NAME = "get_server_info";
+
+/** The build info of `@softure-ai/ops` (`readBuildInfo()`), typed by shape so mcp-access does not import ops. */
+export interface McpBuildInfo {
+  readonly release: string | null;
+  readonly commit: string | null;
+  readonly builtAt: string | null;
+  readonly startedAt: string;
+}
+
+export interface ServerInfoToolOptions {
+  /** The build info, e.g. `() => readBuildInfo()` from `@softure-ai/ops/server` with the route's options. */
+  readonly buildInfo: () => McpBuildInfo | Promise<McpBuildInfo>;
+  /** The changelog the build info route answers, when the app passes one there. Only what is public. */
+  readonly changelog?: () => unknown;
+  /** Default: `serverInfoTool.description` of the module dictionary. */
+  readonly description?: string;
+}
+
+/** What `initialize` answers as `serverInfo`. */
+export interface ServedServerInfo {
+  readonly name: string;
+  readonly version: string;
+}
+
+export interface RegisterServerInfoToolOptions extends ServerInfoToolOptions {
+  /** The name and version the server answers at `initialize`; `createMcpServerFactory` passes them in. */
+  readonly server: ServedServerInfo;
+}
+
+/** The tool's answer: the served name and version, the build info and, with a provider, the changelog. */
+export type ServerInfoAnswer = McpBuildInfo & { readonly server: ServedServerInfo; readonly changelog?: unknown };
+
+/** Registers `get_server_info`: no input fields, read only. A failing `buildInfo` reaches the SDK, which answers a tool error. */
+export function registerServerInfoTool(server: McpServer, options: RegisterServerInfoToolOptions): void {
+  server.registerTool(
+    SERVER_INFO_TOOL_NAME,
+    {
+      description: options.description ?? en.serverInfoTool.description,
+      // An empty object rather than no schema, so strict input refuses a field sent to it.
+      inputSchema: z.object({}),
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+    },
+    async () => toolResult(await readServerInfo(options)),
+  );
+}
+
+async function readServerInfo(options: RegisterServerInfoToolOptions): Promise<ServerInfoAnswer> {
+  const { release, commit, builtAt, startedAt } = await options.buildInfo();
+  const answer: ServerInfoAnswer = { server: { name: options.server.name, version: options.server.version }, release, commit, builtAt, startedAt };
+  return options.changelog === undefined ? answer : { ...answer, changelog: await readChangelog(options.changelog) };
+}
+
+/** As the build info route: a failing provider answers `null` and logs the error class, so the build info still answers. */
+async function readChangelog(provider: () => unknown): Promise<unknown> {
+  try {
+    return (await provider()) ?? null;
+  } catch (error) {
+    console.error(`get_server_info: the changelog provider failed: ${errorLogLabel(error)}`);
+    return null;
+  }
+}

package/src/server/strict-input.ts

@@ -0,0 +1,191 @@
+// Strict tool input. zod objects strip unknown keys, so a tool call with a misspelt field (`notes` for
+// `note`) or a field of a newer tool list answers as a write that worked while the value was dropped.
+// `withStrictToolInput` rewrites every input schema once, at registration: each object refuses a field
+// it does not know and names the ones it accepts, a field sent under its old name is refused with the
+// stable code `input.field_renamed`, and boolean and number fields also take their exact text (a client
+// on an older tool list sends a field it does not know as text). The SDK validates before the handler
+// runs, so a refused call saves nothing.
+//
+//   const server = withStrictToolInput(new McpServer({ name: "acme", version }), { renamedFields: { notes: "note" } });
+import type { McpServer } from "@modelcontextprotocol/server";
+import { formatMessage } from "@softure-ai/core";
+import { z } from "zod";
+import type * as core from "zod/v4/core";
+import { en } from "../messages/en.js";
+
+/** The texts of a refused field: `toolInput` of the module dictionary (`getMcpAccessMessages(config).toolInput`). */
+export type StrictToolInputMessages = typeof en.toolInput;
+
+export interface StrictToolInputOptions {
+  /** Old field name → new field name, refused as `input.field_renamed` wherever an object accepts the new name. */
+  readonly renamedFields?: Readonly<Record<string, string>>;
+  /** Boolean fields also take `"true"`/`"false"` and number fields a number written as text. Default: `true`. */
+  readonly coerceTextScalars?: boolean;
+  /** Default: the module's English dictionary. */
+  readonly messages?: StrictToolInputMessages;
+}
+
+/** A JSON number literal: no spaces, no hex, no empty text. */
+const NUMBER_TEXT = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+
+const strictServers = new WeakSet<McpServer>();
+
+type ToolConfig = Readonly<Record<string, unknown>> & { readonly inputSchema?: unknown };
+type RegisterTool = (name: string, config: ToolConfig, callback: unknown) => unknown;
+
+/** Makes every tool registered on the server from now on strict; wrapping a server twice changes nothing. */
+export function withStrictToolInput<Server extends McpServer>(server: Server, options: StrictToolInputOptions = {}): Server {
+  if (strictServers.has(server)) return server;
+  // The SDK's overloads only differ in how the schema is typed; at runtime it is one method.
+  const register = server.registerTool.bind(server) as unknown as RegisterTool;
+  const registerStrict: RegisterTool = (name, config, callback) =>
+    register(name, config.inputSchema === undefined ? config : { ...config, inputSchema: toStrictToolInput(config.inputSchema, options) }, callback);
+  Object.defineProperty(server, "registerTool", { value: registerStrict, configurable: true, writable: true });
+  strictServers.add(server);
+  return server;
+}
+
+/** The strict form of a tool's input schema: a zod 4 schema or raw shape is rewritten, anything else passes unchanged. */
+export function toStrictToolInput(schema: unknown, options: StrictToolInputOptions = {}): unknown {
+  const zodSchema = isZodSchema(schema) ? schema : isRawShape(schema) ? z.object(schema) : null;
+  if (zodSchema === null) return schema;
+  const rewriter = new StrictRewriter({
+    renamedFields: options.renamedFields ?? {},
+    coerceTextScalars: options.coerceTextScalars ?? true,
+    messages: options.messages ?? en.toolInput,
+  });
+  return rewriter.rewrite(zodSchema);
+}
+
+function isZodSchema(value: unknown): value is core.$ZodType {
+  return typeof value === "object" && value !== null && "_zod" in value;
+}
+
+function isRawShape(value: unknown): value is Record<string, core.$ZodType> {
+  if (typeof value !== "object" || value === null || Object.getPrototypeOf(value) !== Object.prototype) return false;
+  return Object.values(value).every(isZodSchema);
+}
+
+type RewriteSettings = Required<StrictToolInputOptions>;
+
+/** A schema node as the rewriter reads it: its kind and the parts it rewrites. */
+type AnyDef = core.$ZodTypeDef & Record<string, unknown>;
+
+class StrictRewriter {
+  // The same node (a shared field, a recursive `z.lazy`) is rewritten once.
+  private readonly rewritten = new Map<core.$ZodType, core.$ZodType>();
+
+  constructor(private readonly settings: RewriteSettings) {}
+
+  rewrite(schema: core.$ZodType): core.$ZodType {
+    const known = this.rewritten.get(schema);
+    if (known !== undefined) return known;
+    const result = this.rewriteNode(schema);
+    this.rewritten.set(schema, result);
+    return result;
+  }
+
+  private rewriteNode(schema: core.$ZodType): core.$ZodType {
+    const def = schema._zod.def as AnyDef;
+    switch (def.type) {
+      case "object":
+        return this.rewriteObject(schema as core.$ZodObject);
+      case "array":
+        return this.cloneWith(schema, { element: this.rewrite(def.element as core.$ZodType) });
+      case "optional":
+      case "nullable":
+      case "default":
+      case "prefault":
+      case "nonoptional":
+      case "readonly":
+      case "catch":
+        return this.cloneWith(schema, { innerType: this.rewrite(def.innerType as core.$ZodType) });
+      case "union":
+        return this.cloneWith(schema, { options: (def.options as core.$ZodType[]).map((option) => this.rewrite(option)) });
+      case "intersection":
+        return this.cloneWith(schema, { left: this.rewrite(def.left as core.$ZodType), right: this.rewrite(def.right as core.$ZodType) });
+      case "record":
+        return this.cloneWith(schema, { valueType: this.rewrite(def.valueType as core.$ZodType) });
+      case "tuple":
+        return this.cloneWith(schema, {
+          items: (def.items as core.$ZodType[]).map((item) => this.rewrite(item)),
+          rest: def.rest === null ? null : this.rewrite(def.rest as core.$ZodType),
+        });
+      case "pipe":
+        return this.rewritePipe(schema, def);
+      case "lazy": {
+        const getter = def.getter as () => core.$ZodType;
+        return this.cloneWith(schema, { getter: () => this.rewrite(getter()) });
+      }
+      case "boolean":
+        return this.settings.coerceTextScalars && def.coerce !== true ? z.preprocess(readBooleanText, schema) : schema;
+      case "number":
+        return this.settings.coerceTextScalars && def.coerce !== true ? z.preprocess(readNumberText, schema) : schema;
+      default:
+        return schema;
+    }
+  }
+
+  /** Only the input side: `in`, or `out` after a preprocess (whose `in` is the transform). */
+  private rewritePipe(schema: core.$ZodType, def: AnyDef): core.$ZodType {
+    const input = def.in as core.$ZodType;
+    if (input._zod.traits.has("$ZodTransform")) return this.cloneWith(schema, { out: this.rewrite(def.out as core.$ZodType) });
+    return this.cloneWith(schema, { in: this.rewrite(input) });
+  }
+
+  private rewriteObject(schema: core.$ZodObject): core.$ZodType {
+    const def = schema._zod.def;
+    const shape = Object.fromEntries(Object.entries(def.shape).map(([name, field]) => [name, this.rewrite(field)]));
+    // An object with its own catchall (`looseObject`, `.catchall(x)`) accepts extra fields on purpose.
+    if (def.catchall !== undefined && def.catchall._zod.def.type !== "never") return this.cloneWith(schema, { shape });
+    // The object's own map, read for any issue: its parameter type is narrowed to the issues an object raises.
+    const ownError = def.error as core.$ZodErrorMap | undefined;
+    const describe = (issue: core.$ZodRawIssue): string | undefined => describeUnknownFields(issue, Object.keys(shape), this.settings);
+    const error: core.$ZodErrorMap = (issue) => describe(issue) ?? ownError?.(issue);
+    return this.cloneWith(schema, { shape, catchall: z.never(), error });
+  }
+
+  /** A copy of the node with some parts replaced; its description and other metadata stay with it. */
+  private cloneWith(schema: core.$ZodType, parts: Record<string, unknown>): core.$ZodType {
+    const copy = (schema as unknown as z.ZodType).clone({ ...schema._zod.def, ...parts });
+    const meta = z.globalRegistry.get(schema);
+    if (meta !== undefined) {
+      // An id names one schema in the JSON Schema output; the copy replaces the original, so it may not carry it twice.
+      const rest = { ...meta };
+      delete rest.id;
+      z.globalRegistry.add(copy, rest);
+    }
+    return copy;
+  }
+}
+
+/** The text for an object's unknown fields: renamed ones first, then the rest with the fields it accepts. */
+function describeUnknownFields(issue: core.$ZodRawIssue, accepted: readonly string[], settings: RewriteSettings): string | undefined {
+  if (issue.code !== "unrecognized_keys") return undefined;
+  const { messages, renamedFields } = settings;
+  const renamed: string[] = [];
+  const unknown: string[] = [];
+  for (const field of issue.keys) {
+    const newName = Object.hasOwn(renamedFields, field) ? renamedFields[field] : undefined;
+    if (newName !== undefined && accepted.includes(newName)) renamed.push(formatMessage(messages.fieldRenamed, { field, renamed: newName }));
+    else unknown.push(field);
+  }
+  if (unknown.length > 0) {
+    renamed.push(formatMessage(messages.unknownFields, { fields: quoteAll(unknown), accepted: accepted.length > 0 ? quoteAll(accepted) : messages.noFields }));
+  }
+  return renamed.join(" ");
+}
+
+function quoteAll(names: readonly string[]): string {
+  return names.map((name) => JSON.stringify(name)).join(", ");
+}
+
+function readBooleanText(value: unknown): unknown {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}
+
+function readNumberText(value: unknown): unknown {
+  return typeof value === "string" && NUMBER_TEXT.test(value) ? Number(value) : value;
+}

package/src/server/tokens.ts

@@ -159,6 +159,16 @@ export interface VerifiedAccessToken {
   readonly grantId: string | null;
 }
 
+/**
+ * A token's name, the client it was issued for ("Laptop", an OAuth client's name), for a record of tool calls:
+ * `null` for an id that is not a stored token's (the stdio id, a pruned or unknown token).
+ */
+export async function findTokenClientName(ctx: McpAccessContext, tokenId: string): Promise<string | null> {
+  if (!UUID_SHAPE.test(tokenId)) return null;
+  const [row] = await ctx.db.select({ name: accessTokens.name }).from(accessTokens).where(eq(accessTokens.id, tokenId));
+  return row?.name ?? null;
+}
+
 /**
  * The identity behind a token, or null for anything unknown, revoked or expired: the caller cannot
  * tell which, so a guess learns nothing. The expiry sits in the query, so no code path can forget

package/src/server/tool-list.ts

@@ -0,0 +1,105 @@
+// The server version that follows the tool list. MCP clients keep a cached `tools/list` until the
+// version they read at `initialize` changes, so a release that adds a tool or changes a schema under
+// the same version leaves the assistant on the old schemas. `measureToolList` fingerprints the list
+// as the client reads it, `<release>-tools-<12 hex>`: a semver prerelease, since comparisons ignore
+// build metadata. The same registrations always give the same version.
+import { createHash } from "node:crypto";
+import { createMcpHandler, McpServer, METHOD_NOT_FOUND, type McpServerOptions, type Server } from "@modelcontextprotocol/server";
+
+/** The release part when none is given. */
+export const DEFAULT_TOOL_LIST_RELEASE = "1.0.0";
+
+/** Hex digits of the fingerprint in the version. */
+const FINGERPRINT_LENGTH = 12;
+const RELEASE_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+
+/** What a client reads from `tools/list`: one entry per tool, as JSON. */
+export type ServedTool = Readonly<Record<string, unknown>> & { readonly name: string };
+
+export interface ToolListMeasurement {
+  /** `<release>-tools-<12 hex>`, for `serverInfo.version`. */
+  readonly toolListVersion: string;
+  readonly toolCount: number;
+}
+
+/** Registers the app's tools on the server it is given, e.g. `(server) => registerNoteTools(server, identity)`. */
+export type RegisterTools = (server: McpServer) => unknown;
+
+export interface MeasureToolListOptions {
+  /** The `MAJOR.MINOR.PATCH` before `-tools-`. Default: `1.0.0`. */
+  readonly release?: string;
+  /** The served server's name, so the recording server is shaped like it. Default: `tool-list`. */
+  readonly name?: string;
+  /** The served server's options (capabilities, instructions), for the same reason. */
+  readonly serverOptions?: McpServerOptions;
+}
+
+/**
+ * Registers the tools on a recording server shaped like the served one, lists them the way the endpoint
+ * serves them and returns the version with the tool count. Any change of a tool's name, title,
+ * description, annotations or input or output schema changes the version; the order of registration does not.
+ */
+export async function measureToolList(registerTools: RegisterTools, options: MeasureToolListOptions = {}): Promise<ToolListMeasurement> {
+  const release = options.release ?? DEFAULT_TOOL_LIST_RELEASE;
+  assertRelease(release);
+  const server = new McpServer({ name: options.name ?? "tool-list", version: release }, options.serverOptions);
+  await registerTools(server);
+  return describeToolList(await listServedTools(() => server), release);
+}
+
+/** The version and count for a listed tool set. */
+export function describeToolList(tools: readonly ServedTool[], release: string = DEFAULT_TOOL_LIST_RELEASE): ToolListMeasurement {
+  assertRelease(release);
+  return { toolListVersion: `${release}-tools-${fingerprintToolList(tools)}`, toolCount: tools.length };
+}
+
+/** The first 12 hex digits of a sha256 over the tools in name order, each as canonical JSON (keys sorted at every level). */
+export function fingerprintToolList(tools: readonly ServedTool[]): string {
+  const ordered = [...tools].sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+  return createHash("sha256").update(toCanonicalJson(ordered)).digest("hex").slice(0, FINGERPRINT_LENGTH);
+}
+
+/** Every tool a fresh server from the factory lists (none when it registered none), asked with one stateless `tools/list` as the endpoint serves it. */
+export async function listServedTools(createServer: () => McpServer | Server | Promise<McpServer | Server>): Promise<ServedTool[]> {
+  const handler = createMcpHandler(createServer, { responseMode: "json" });
+  const response = await handler.fetch(
+    new Request("http://localhost/api/mcp", {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json, text/event-stream" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }),
+    }),
+  );
+  const answer = readAnswer(await response.text());
+  // A server that registered no tool declares no tools capability, so it does not know the method.
+  if (answer.error?.code === METHOD_NOT_FOUND) return [];
+  if (answer.result?.tools === undefined) {
+    throw new Error(`@softure-ai/mcp-access: listing the server's tools failed: ${typeof answer.error?.message === "string" ? answer.error.message : `HTTP ${String(response.status)}`}`);
+  }
+  return answer.result.tools.filter((tool): tool is ServedTool => typeof tool.name === "string" && tool.name !== "");
+}
+
+interface ToolsListAnswer {
+  readonly result?: { readonly tools?: readonly (Readonly<Record<string, unknown>> & { readonly name?: unknown })[] };
+  readonly error?: { readonly code?: unknown; readonly message?: unknown };
+}
+
+/** The JSON-RPC answer, sent as JSON or as one SSE `message` event. */
+function readAnswer(body: string): ToolsListAnswer {
+  const data = body.startsWith("event:") ? (body.split("\n").find((line) => line.startsWith("data: "))?.slice("data: ".length) ?? "null") : body;
+  return (JSON.parse(data) ?? {}) as ToolsListAnswer;
+}
+
+function toCanonicalJson(value: unknown): string {
+  return JSON.stringify(value, (_key, entry: unknown) =>
+    entry !== null && typeof entry === "object" && !Array.isArray(entry)
+      ? Object.fromEntries(Object.entries(entry).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)))
+      : entry,
+  );
+}
+
+/** A release that is not `MAJOR.MINOR.PATCH` would make an invalid version: a setup bug, thrown. */
+function assertRelease(release: string): void {
+  if (!RELEASE_PATTERN.test(release)) {
+    throw new Error(`@softure-ai/mcp-access: the tool list release must be MAJOR.MINOR.PATCH, got "${release}"`);
+  }
+}