@dereekb/firebase-server 13.11.17 → 13.12.0

package/mcp/index.cjs.js

@@ -0,0 +1,3646 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var node_fs = require('node:fs');
+var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var oidc = require('@dereekb/firebase-server/oidc');
+var util = require('@dereekb/util');
+var firebaseServer = require('@dereekb/firebase-server');
+var node_util = require('node:util');
+var model = require('@dereekb/model');
+var firebase = require('@dereekb/firebase');
+var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$6(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Default path the MCP Streamable HTTP transport is mounted at.
+ *
+ * Combined with the app origin to form the canonical MCP resource URL
+ * (e.g., `https://api.example.com/mcp`) advertised in the protected-resource
+ * discovery document at `/.well-known/oauth-protected-resource`.
+ */ var DEFAULT_MCP_PATH = '/mcp';
+/**
+ * Default name advertised by the MCP server on the JSON-RPC `initialize` handshake.
+ *
+ * Apps may override this via {@link McpModuleConfig.serverName} to identify their
+ * deployment (e.g., `demo-api-mcp`, `hellosubs-api-mcp`).
+ */ var DEFAULT_MCP_SERVER_NAME = 'dbx-firebase-server-mcp';
+/**
+ * Configuration for the firebase-server/mcp module.
+ *
+ * Apps construct this in their `*McpModule` provider and pass it through
+ * {@link mcpModuleMetadata}. It carries:
+ *
+ * - The canonical issuer URL for the OIDC provider that gates this MCP endpoint
+ *   (used in the protected-resource discovery document).
+ * - The canonical resource URL where the MCP transport is mounted (also part of
+ *   the discovery document; doubles as the `resource` claim consumers should
+ *   verify their access tokens against).
+ * - Optional server identity (name, version) advertised on the MCP `initialize` handshake.
+ *
+ * The OAuth bearer middleware that authenticates `/mcp` is configured on
+ * {@link OidcModuleConfig.protectedPaths} — that's outside this config's scope.
+ */ var McpModuleConfig = function McpModuleConfig() {
+    _class_call_check$3(this, McpModuleConfig);
+    /**
+     * The canonical issuer URL of the OIDC provider that gates this MCP endpoint.
+     *
+     * Surfaced in the `authorization_servers` field of the protected-resource
+     * discovery document. Claude custom-connector reads this to discover the OIDC issuer.
+     *
+     * @example 'https://api.example.com/oidc'
+     */ _define_property$6(this, "oidcIssuer", void 0);
+    /**
+     * The canonical resource URL of the MCP endpoint.
+     *
+     * Surfaced as the `resource` field of the protected-resource discovery document,
+     * and used as the audience the access token's `aud` claim should match.
+     *
+     * @example 'https://api.example.com/mcp'
+     */ _define_property$6(this, "mcpUrl", void 0);
+    /**
+     * Optional name advertised on the MCP `initialize` handshake. Defaults to
+     * {@link DEFAULT_MCP_SERVER_NAME}.
+     */ _define_property$6(this, "serverName", void 0);
+    /**
+     * Optional version advertised on the MCP `initialize` handshake.
+     */ _define_property$6(this, "serverVersion", void 0);
+    /**
+     * Absolute path to a pre-rendered MCP manifest JSON file produced by
+     * `dbx-cli-generate-mcp-manifest`. When set, the runtime reads it once at
+     * boot and uses each tool's `description`, `inputSchema`, and `outputSchema`
+     * during tool generation — no per-request file I/O.
+     *
+     * Optional. When unset or the file is missing, the runtime falls back to
+     * today's behavior (auto-generated descriptions, ArkType-derived input
+     * schemas, no output schemas) and emits a single boot warning.
+     */ _define_property$6(this, "mcpManifestPath", void 0);
+    /**
+     * When `true`, the MCP server only advertises tools whose effective read-only classification is `true`.
+     *
+     * Write tools (`create`/`update`/`delete`) and tools with unknown classification (e.g., `invoke`
+     * with no explicit `mcp.readOnly` override) are dropped from `tools/list` — fail-safe under the
+     * principle that anything not provably read-only is treated as a write.
+     *
+     * The advertised `serverName` on the JSON-RPC `initialize` handshake is suffixed with
+     * ` (read-only)` so the client surface reflects the mode.
+     */ _define_property$6(this, "readOnly", void 0);
+};
+/**
+ * NestJS injection token for the optional {@link McpAuthRoleReader} provider.
+ */ var MCP_AUTH_ROLE_READER = 'MCP_AUTH_ROLE_READER';
+
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ((typeof Reflect === "undefined" ? "undefined" : _type_of$1(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Version stamp embedded in the build-time MCP manifest JSON. Runtime loaders
+ * refuse manifests whose `version` does not match this constant.
+ *
+ * Mirrors {@link MCP_MANIFEST_VERSION} in `@dereekb/dbx-cli` — both packages
+ * version-bump together when the manifest shape changes.
+ */ var MCP_MANIFEST_VERSION = 1;
+/**
+ * Builds the canonical MCP manifest key for a (modelType, callType, specifier) triple.
+ *
+ * Default-specifier entries collapse to `_`. Must stay in sync with the build-time
+ * helper of the same name in `@dereekb/dbx-cli`.
+ *
+ * @param modelType - The Firestore model type segment of the key.
+ * @param call - The call type segment of the key.
+ * @param specifier - The specifier segment, or `_` / undefined for the default entry.
+ * @returns The canonical `modelType.call.specifier` manifest key.
+ */ function mcpManifestKey(modelType, call, specifier) {
+    var isDefault = specifier == null || specifier === '_';
+    return isDefault ? "".concat(modelType, ".").concat(call, "._") : "".concat(modelType, ".").concat(call, ".").concat(specifier);
+}
+
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+/**
+ * Default structured value emitted by MCP when a handler returns `undefined`.
+ *
+ * Keeps the response usable by clients that key off either the text content or the
+ * structured/object body. Tests and any future overrides should compare against this
+ * constant rather than re-literalling `{ ok: true }`.
+ */ var DEFAULT_VOID_MCP_SUCCESS_VALUE = Object.freeze({
+    ok: true
+});
+/**
+ * Resolves a dispatch result + handler API details into the MCP `CallToolResult` shape.
+ *
+ * Three-tier resolution as documented on {@link OnCallModelFunctionApiDetails.mcp}:
+ *
+ * - **Tier 3** — when `mcp.formatResponse` is set, its return value is used verbatim.
+ * - **Tier 2** — when `mcp.summarizeResponse` is set, the summary string is wrapped into a
+ *   single text content block with the raw `result` exposed as `structuredContent`.
+ * - **Tier 1** — default: JSON-stringify `result` as a single text content block, also
+ *   exposing the raw value as `structuredContent`.
+ *
+ * @param result - The handler's return value.
+ * @param params - The {@link OnCallTypedModelParams} that were dispatched.
+ * @param details - The handler-level API details (carries Tier 2/3 formatters).
+ * @returns The MCP tool response content.
+ */ function formatMcpToolResponse(result, params, details) {
+    var mcp = details === null || details === void 0 ? void 0 : details.mcp;
+    var response;
+    if (mcp === null || mcp === void 0 ? void 0 : mcp.formatResponse) {
+        response = mcp.formatResponse(result, params);
+    } else if (mcp === null || mcp === void 0 ? void 0 : mcp.summarizeResponse) {
+        var summary = mcp.summarizeResponse(result, params);
+        response = {
+            content: [
+                {
+                    type: 'text',
+                    text: summary
+                }
+            ],
+            structuredContent: result
+        };
+    } else {
+        response = {
+            content: [
+                {
+                    type: 'text',
+                    text: stringifyResult(result)
+                }
+            ],
+            structuredContent: result === undefined ? DEFAULT_VOID_MCP_SUCCESS_VALUE : result
+        };
+    }
+    return response;
+}
+/**
+ * Converts an error thrown from the dispatch chain into the MCP error response shape.
+ *
+ * @param error - The thrown error.
+ * @returns An MCP tool response with `isError: true` and the error message as a text block.
+ */ function formatMcpToolErrorResponse(error) {
+    var message = _instanceof(error, Error) ? error.message : String(error);
+    return {
+        isError: true,
+        content: [
+            {
+                type: 'text',
+                text: message
+            }
+        ]
+    };
+}
+function stringifyResult(result) {
+    var text;
+    if (result === undefined) {
+        text = JSON.stringify(DEFAULT_VOID_MCP_SUCCESS_VALUE);
+    } else if (typeof result === 'string') {
+        text = result;
+    } else {
+        try {
+            text = JSON.stringify(result, null, 2);
+        } catch (unused) {
+            text = node_util.inspect(result, {
+                depth: 4
+            });
+        }
+    }
+    return text;
+}
+
+/**
+ * Classifies a {@link McpToolVisibility} value into its normalized boot-time form.
+ *
+ * Defaults `undefined` to `'always'` so handlers without a visibility field stay visible.
+ *
+ * @param visibility - The raw visibility value from the handler's `mcp.visibility` field.
+ * @returns The discriminated classification used by the per-request filter loop.
+ */ function classifyVisibility(visibility) {
+    var result;
+    if (visibility == null || visibility === true) {
+        result = {
+            visibilityKind: 'always'
+        };
+    } else if (visibility === false) {
+        result = {
+            visibilityKind: 'never'
+        };
+    } else if (typeof visibility === 'function') {
+        result = {
+            visibilityKind: 'dynamic',
+            visibilityFn: visibility
+        };
+    } else {
+        result = {
+            visibilityKind: 'declarative',
+            rule: visibility
+        };
+    }
+    return result;
+}
+/**
+ * Inference table from CRUD call type to "is this a read operation?".
+ *
+ * `read` and `query` → true. `create`/`update`/`delete` → false. Anything else → undefined.
+ * Unknown call types (custom verbs, `invoke`) intentionally leave `effectiveReadOnly`
+ * undefined so the module-level `readOnly` filter treats them as writes (fail-safe).
+ */ var READ_ONLY_BY_CALL_TYPE = {
+    read: true,
+    query: true,
+    create: false,
+    update: false,
+    delete: false
+};
+/**
+ * Resolves the effective read-only classification for a handler.
+ *
+ * Explicit handler override wins. Otherwise infers from the call type. Returns
+ * `undefined` when neither source provides a definite classification.
+ *
+ * @param explicitReadOnly - The handler's explicit `mcp.readOnly` value, if any.
+ * @param callType - The dispatch call type used to infer read-only when no override is present.
+ * @returns The effective read-only flag, or `undefined` when neither source resolves a value.
+ */ function resolveEffectiveReadOnly(explicitReadOnly, callType) {
+    if (explicitReadOnly != null) {
+        return explicitReadOnly;
+    }
+    return READ_ONLY_BY_CALL_TYPE[callType];
+}
+/**
+ * Resolves the OIDC scope required to invoke a given call type, or `undefined` for
+ * non-CRUD calls. Thin re-export so the tool generator doesn't need to reach into
+ * `@dereekb/firebase` directly.
+ *
+ * @param callType - The dispatch call type to map to a CRUD OIDC scope.
+ * @returns The required scope for this call type, or `undefined` when no scope is enforced.
+ */ function resolveRequiredScope(callType) {
+    return firebase.callModelOidcScopeForCallType(callType);
+}
+
+function _array_like_to_array$4(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$2(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit$2(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$2() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array$2(arr, i) {
+    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$4(arr, i) || _non_iterable_rest$2();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$4(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
+}
+/**
+ * Default `toJsonSchema()` options.
+ *
+ * ArkType throws on predicate definitions and on `undefined` fields by default;
+ * these fallback handlers downgrade those errors so a partial schema is emitted
+ * for tools that mostly fit JSON Schema. The `unit` fallback covers `clearable(t)`
+ * from `@dereekb/model` (which expands to `t | undefined` and surfaces as an ArkType
+ * `unit: undefined` schema node).
+ */ var DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS = {
+    fallback: {
+        predicate: function predicate() {
+            return {};
+        },
+        unit: function unit() {
+            return {};
+        },
+        undefinedAsClearable: function undefinedAsClearable() {
+            return {};
+        }
+    }
+};
+/**
+ * Builds the frozen wire-shape entry used by the per-request `tools/list` hot path.
+ *
+ * Tools without an `inputSchema` default to `{ type: 'object' }` to match the runtime
+ * behaviour the factory used before the precompute optimisation existed.
+ *
+ * @param input - The tool name, description, and optional input/output schemas used to assemble the wire entry.
+ * @returns A frozen wire entry safe to share across requests.
+ */ function buildStaticWireEntry(input) {
+    var _input_inputSchema;
+    var inputSchema = (_input_inputSchema = input.inputSchema) !== null && _input_inputSchema !== void 0 ? _input_inputSchema : {
+        type: 'object'
+    };
+    var entry = input.outputSchema == null ? {
+        name: input.name,
+        description: input.description,
+        inputSchema: inputSchema
+    } : {
+        name: input.name,
+        description: input.description,
+        inputSchema: inputSchema,
+        outputSchema: input.outputSchema
+    };
+    return Object.freeze(entry);
+}
+// MARK: Naming
+/**
+ * The default specifier key used when a handler is not behind a specifier router.
+ */ var DEFAULT_SPECIFIER_KEY = '_';
+/**
+ * Builds the MCP tool name for a (modelType, callType, specifier) triple.
+ *
+ * Apps can override the auto-generated name by setting
+ * {@link OnCallModelFunctionApiDetails.mcp.name} on the handler.
+ *
+ * @param modelType - The Firestore model type (e.g., `storageFile`).
+ * @param callType - The call type (e.g., `invoke`).
+ * @param specifier - The specifier key, or `_` / undefined for the default entry.
+ * @returns The hyphen-joined tool name advertised on `tools/list`.
+ */ function buildMcpToolName(modelType, callType, specifier) {
+    var isDefault = specifier == null || specifier === DEFAULT_SPECIFIER_KEY;
+    return isDefault ? "".concat(modelType, "-").concat(callType) : "".concat(modelType, "-").concat(callType, "-").concat(specifier);
+}
+/**
+ * Builds the default description used when no build-time MCP manifest
+ * entry is available for the (modelType, callType, specifier) tuple.
+ *
+ * @param modelType - The Firestore model type segment used in the generated description.
+ * @param callType - The call type segment used in the generated description.
+ * @param specifier - The specifier segment, or `_` / undefined for the default entry.
+ * @returns A human-readable fallback description for the tool.
+ */ function buildDefaultMcpToolDescription(modelType, callType, specifier) {
+    var isDefault = specifier == null || specifier === DEFAULT_SPECIFIER_KEY;
+    return isDefault ? 'Performs the "'.concat(callType, '" call on the "').concat(modelType, '" model.') : 'Performs the "'.concat(callType, '" call on the "').concat(modelType, '" model with the "').concat(specifier, '" specifier.');
+}
+// MARK: Generation
+/**
+ * Generates MCP tool definitions from a model-first API details tree.
+ *
+ * Walks each (modelType, callType, specifier) triple in the tree, calls
+ * `inputType.toJsonSchema(options)` for the schema, and applies any handler-level
+ * MCP `name` override. Descriptions and input/output schemas are pulled from the
+ * build-time manifest when supplied. Tools without an `inputType` are skipped and
+ * reported so callers can log the gap at startup.
+ *
+ * @param apiDetails - The model-first API details tree returned by `getModelApiDetails(callModelFn)`.
+ * @param options - Optional schema generation options forwarded to `toJsonSchema()`. Defaults to {@link DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS}.
+ * @param manifest - Optional build-time manifest map; supplies overrides for descriptions and input/output schemas keyed by {@link mcpManifestKey}.
+ * @returns The list of generated tool definitions plus any skip reports.
+ */ function generateMcpToolDefinitions(apiDetails) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS, manifest = arguments.length > 2 ? arguments[2] : void 0;
+    var tools = [];
+    var neverVisibleTools = [];
+    var skipped = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(apiDetails.models)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array$2(_step.value, 2), modelType = _step_value[0], modelEntry = _step_value[1];
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = Object.entries(modelEntry.calls)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var _step_value1 = _sliced_to_array$2(_step1.value, 2), callType = _step_value1[0], callDetails = _step_value1[1];
+                    if (callDetails == null) {
+                        continue;
+                    }
+                    generateToolsForModelCall({
+                        modelType: modelType,
+                        callType: callType,
+                        callDetails: callDetails,
+                        options: options,
+                        manifest: manifest,
+                        outTools: tools,
+                        outNeverVisibleTools: neverVisibleTools,
+                        outSkipped: skipped
+                    });
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return {
+        tools: tools,
+        neverVisibleTools: neverVisibleTools,
+        skipped: skipped
+    };
+}
+function generateToolsForModelCall(context) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(context.callDetails.specifiers)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array$2(_step.value, 2), specifierKey = _step_value[0], handlerDetails = _step_value[1];
+            if (handlerDetails != null) {
+                generateToolForSpecifier(context, specifierKey, handlerDetails);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+function generateToolForSpecifier(context, specifierKey, handlerDetails) {
+    var _ref, _ref1, _resolveRequiredScope;
+    var _handlerDetails_mcp, _handlerDetails_mcp1, _handlerDetails_mcp2, _handlerDetails_mcp3;
+    var modelType = context.modelType, callType = context.callType, callDetails = context.callDetails, options = context.options, manifest = context.manifest, outTools = context.outTools, outNeverVisibleTools = context.outNeverVisibleTools, outSkipped = context.outSkipped;
+    var specifier = callDetails.isSpecifier ? specifierKey : undefined;
+    var dispatch = {
+        call: callType,
+        modelType: modelType,
+        specifier: specifier
+    };
+    var name = (_ref = (_handlerDetails_mcp = handlerDetails.mcp) === null || _handlerDetails_mcp === void 0 ? void 0 : _handlerDetails_mcp.name) !== null && _ref !== void 0 ? _ref : buildMcpToolName(modelType, callType, specifier);
+    var manifestEntry = manifest === null || manifest === void 0 ? void 0 : manifest.get(mcpManifestKey(modelType, callType, specifier));
+    var description = (_ref1 = manifestEntry === null || manifestEntry === void 0 ? void 0 : manifestEntry.description) !== null && _ref1 !== void 0 ? _ref1 : buildDefaultMcpToolDescription(modelType, callType, specifier);
+    var inputSchema = resolveInputSchema({
+        handlerDetails: handlerDetails,
+        manifestEntry: manifestEntry,
+        options: options,
+        dispatch: dispatch,
+        toolName: name,
+        outSkipped: outSkipped
+    });
+    if (inputSchema == null) {
+        return;
+    }
+    var classified = classifyVisibility((_handlerDetails_mcp1 = handlerDetails.mcp) === null || _handlerDetails_mcp1 === void 0 ? void 0 : _handlerDetails_mcp1.visibility);
+    var requiredScope = (_resolveRequiredScope = resolveRequiredScope(callType)) !== null && _resolveRequiredScope !== void 0 ? _resolveRequiredScope : undefined;
+    var effectiveReadOnly = resolveEffectiveReadOnly((_handlerDetails_mcp2 = handlerDetails.mcp) === null || _handlerDetails_mcp2 === void 0 ? void 0 : _handlerDetails_mcp2.readOnly, callType);
+    var filterMetadata;
+    if (classified.visibilityKind === 'declarative') {
+        filterMetadata = {
+            visibilityKind: 'declarative',
+            rule: classified.rule,
+            requiredScope: requiredScope,
+            effectiveReadOnly: effectiveReadOnly
+        };
+    } else if (classified.visibilityKind === 'dynamic') {
+        filterMetadata = {
+            visibilityKind: 'dynamic',
+            visibilityFn: classified.visibilityFn,
+            requiredScope: requiredScope,
+            effectiveReadOnly: effectiveReadOnly
+        };
+    } else {
+        filterMetadata = {
+            visibilityKind: classified.visibilityKind,
+            requiredScope: requiredScope,
+            effectiveReadOnly: effectiveReadOnly
+        };
+    }
+    var outputSchema = manifestEntry === null || manifestEntry === void 0 ? void 0 : manifestEntry.outputSchema;
+    var staticWireEntry = buildStaticWireEntry({
+        name: name,
+        description: description,
+        inputSchema: inputSchema,
+        outputSchema: outputSchema
+    });
+    var definition = {
+        name: name,
+        description: description,
+        inputSchema: inputSchema,
+        outputSchema: outputSchema,
+        details: handlerDetails,
+        dispatch: dispatch,
+        filterMetadata: filterMetadata,
+        staticWireEntry: staticWireEntry,
+        toolDetailsBuilder: (_handlerDetails_mcp3 = handlerDetails.mcp) === null || _handlerDetails_mcp3 === void 0 ? void 0 : _handlerDetails_mcp3.toolDetails
+    };
+    if (filterMetadata.visibilityKind === 'never') {
+        outNeverVisibleTools.push(definition);
+    } else {
+        outTools.push(definition);
+    }
+}
+function resolveInputSchema(context) {
+    var handlerDetails = context.handlerDetails, manifestEntry = context.manifestEntry, options = context.options, dispatch = context.dispatch, toolName = context.toolName, outSkipped = context.outSkipped;
+    if ((manifestEntry === null || manifestEntry === void 0 ? void 0 : manifestEntry.inputSchema) != null) {
+        return manifestEntry.inputSchema;
+    }
+    if (handlerDetails.inputType == null) {
+        outSkipped.push({
+            toolName: toolName,
+            reason: 'missing_input_type',
+            dispatch: dispatch
+        });
+        return undefined;
+    }
+    var result;
+    try {
+        var exported = model.arktypeToJsonSchemaForExport(handlerDetails.inputType);
+        if (exported && (typeof exported === "undefined" ? "undefined" : _type_of(exported)) === 'object') {
+            result = exported;
+        } else {
+            // arktypeToJsonSchemaForExport returned a non-object (shouldn't happen for object schemas).
+            // Fall back to the raw arktype output preserving the legacy options for safety.
+            result = handlerDetails.inputType.toJsonSchema(options);
+        }
+    } catch (error) {
+        outSkipped.push({
+            toolName: toolName,
+            reason: 'schema_generation_failed',
+            dispatch: dispatch,
+            error: error
+        });
+        result = undefined;
+    }
+    return result;
+}
+
+function _array_like_to_array$3(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$3(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
+}
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array$3(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$3() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$3(arr) {
+    return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$3();
+}
+function _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+}
+function _ts_generator$3(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+// MARK: Constants
+/**
+ * Reserved tool name for the built-in `model-get` static tool.
+ */ var MODEL_GET_TOOL_NAME = 'model-get';
+/**
+ * Synthetic call type used in the tool's dispatch identity. Aligns with the dbx-cli `get`
+ * command and the `/api/model/:modelType/get` HTTP endpoint that backs it.
+ */ var MODEL_GET_DISPATCH_CALL = 'get';
+/**
+ * Synthetic model type used in the tool's dispatch identity. The tool itself isn't bound to a
+ * specific model type (the `modelType` is part of its input), so we use the literal "model" as
+ * the identity. Apps avoiding collision should not register a real model literally named
+ * "model".
+ */ var MODEL_GET_DISPATCH_MODEL_TYPE = 'model';
+/**
+ * Maximum number of keys per backend multi-read request. Matches
+ * `MAX_MODEL_ACCESS_MULTI_READ_KEYS` exported from `@dereekb/firebase-server`; mirrored as a
+ * local constant so the bundler doesn't have to follow the import chain just for one number.
+ */ var MCP_MODEL_GET_BATCH_SIZE = 50;
+// MARK: Factory
+/**
+ * Builds the built-in `model-get` MCP tool definition.
+ *
+ * Mirrors dbx-cli's `get` / `get-many` behavior:
+ * - Accepts an array of keys; values containing `/` are treated as full keys and passed verbatim
+ *   while bare ids are promoted to `${collectionName}/${id}` for root models.
+ * - Nested (subcollection) models reject bare ids since a parent path is required.
+ * - Auto-chunks at {@link MCP_MODEL_GET_BATCH_SIZE} keys per backend call, mirroring
+ *   `getMultipleModelsOverHttpChunked` on the CLI side.
+ *
+ * The handler returns the same `{ results, errors }` shape produced by
+ * `ModelApiGetService.readDocuments`, exposed via both the text content block and
+ * `structuredContent` so MCP clients can consume either form.
+ *
+ * @param deps - Read-documents and identity-resolver callbacks (typically wired to
+ *   `ModelApiGetService`).
+ * @returns A statically-registered {@link McpToolDefinition} ready to be appended to the MCP
+ *   server factory's tool registry.
+ */ function createModelGetTool(deps) {
+    var handler = function handler(args, ctx) {
+        return modelGetToolHandler(args, ctx, deps);
+    };
+    var name = MODEL_GET_TOOL_NAME;
+    var description = 'Fetch one or more Firestore model documents by key or bare id. Values containing `/` are treated as full keys; bare ids are auto-promoted to `<collectionName>/<id>` for root models. Subcollection models require full keys.';
+    return {
+        name: name,
+        description: description,
+        inputSchema: MODEL_GET_INPUT_SCHEMA,
+        outputSchema: MODEL_GET_OUTPUT_SCHEMA,
+        dispatch: {
+            call: MODEL_GET_DISPATCH_CALL,
+            modelType: MODEL_GET_DISPATCH_MODEL_TYPE
+        },
+        staticHandler: handler,
+        filterMetadata: {
+            visibilityKind: 'declarative',
+            rule: {
+                requireAuthenticated: true
+            },
+            effectiveReadOnly: true
+        },
+        staticWireEntry: buildStaticWireEntry({
+            name: name,
+            description: description,
+            inputSchema: MODEL_GET_INPUT_SCHEMA,
+            outputSchema: MODEL_GET_OUTPUT_SCHEMA
+        })
+    };
+}
+// MARK: Handler
+function modelGetToolHandler(args, ctx, deps) {
+    return _async_to_generator$3(function() {
+        var result, input, identity, resolvedKeys, merged, error;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    input = parseModelGetInput(args);
+                    identity = deps.resolveIdentity(input.modelType, ctx.auth);
+                    if (identity == null) {
+                        throw new Error("Unknown modelType: ".concat(input.modelType));
+                    }
+                    resolvedKeys = resolveKeys(input.keys, identity);
+                    return [
+                        4,
+                        readInChunks({
+                            modelType: input.modelType,
+                            keys: resolvedKeys,
+                            auth: ctx.auth,
+                            readDocuments: deps.readDocuments
+                        })
+                    ];
+                case 1:
+                    merged = _state.sent();
+                    result = {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(merged)
+                            }
+                        ],
+                        structuredContent: merged
+                    };
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    error = _state.sent();
+                    result = formatMcpToolErrorResponse(error);
+                    return [
+                        3,
+                        3
+                    ];
+                case 3:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+function parseModelGetInput(args) {
+    var modelType = args.modelType;
+    var keys = args.keys;
+    if (typeof modelType !== 'string' || modelType.length === 0) {
+        throw new Error('model-get: "modelType" is required and must be a non-empty string.');
+    }
+    if (!Array.isArray(keys) || keys.length === 0) {
+        throw new Error('model-get: "keys" is required and must be a non-empty array.');
+    }
+    var normalizedKeys = keys.map(function(value, index) {
+        if (typeof value !== 'string' || value.length === 0) {
+            throw new Error("model-get: keys[".concat(index, "] must be a non-empty string."));
+        }
+        return value;
+    });
+    return {
+        modelType: modelType,
+        keys: normalizedKeys
+    };
+}
+function resolveKeys(keys, identity) {
+    var isRoot = identity.type === 'root';
+    var resolved = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var value = _step.value;
+            if (value.includes('/')) {
+                resolved.push(value);
+            } else if (isRoot) {
+                resolved.push("".concat(identity.collectionName, "/").concat(value));
+            } else {
+                throw new Error('model-get: modelType "'.concat(identity.modelType, '" is a subcollection; bare ids are not allowed. Provide full keys (e.g. "parentPrefix/parentId/').concat(identity.collectionName, "/").concat(value, '").'));
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return resolved;
+}
+function readInChunks(input) {
+    return _async_to_generator$3(function() {
+        var modelType, keys, auth, readDocuments, merged, offset, _merged_results, _merged_errors, batch, partial;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    modelType = input.modelType, keys = input.keys, auth = input.auth, readDocuments = input.readDocuments;
+                    merged = {
+                        results: [],
+                        errors: []
+                    };
+                    offset = 0;
+                    _state.label = 1;
+                case 1:
+                    if (!(offset < keys.length)) return [
+                        3,
+                        4
+                    ];
+                    batch = keys.slice(offset, offset + MCP_MODEL_GET_BATCH_SIZE);
+                    return [
+                        4,
+                        readDocuments(modelType, batch, auth)
+                    ];
+                case 2:
+                    partial = _state.sent();
+                    (_merged_results = merged.results).push.apply(_merged_results, _to_consumable_array$3(partial.results));
+                    (_merged_errors = merged.errors).push.apply(_merged_errors, _to_consumable_array$3(partial.errors));
+                    _state.label = 3;
+                case 3:
+                    offset += MCP_MODEL_GET_BATCH_SIZE;
+                    return [
+                        3,
+                        1
+                    ];
+                case 4:
+                    return [
+                        2,
+                        merged
+                    ];
+            }
+        });
+    })();
+}
+// MARK: Schemas
+var MODEL_GET_INPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'modelType',
+        'keys'
+    ],
+    properties: {
+        modelType: {
+            type: 'string',
+            minLength: 1,
+            description: 'Firestore model type to fetch (e.g. "guestbook", "profile").'
+        },
+        keys: {
+            type: 'array',
+            minItems: 1,
+            description: 'Full keys ("prefix/id") or bare ids (root models only).',
+            items: {
+                type: 'string',
+                minLength: 1
+            }
+        }
+    },
+    additionalProperties: false
+};
+var MODEL_GET_OUTPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'results',
+        'errors'
+    ],
+    properties: {
+        results: {
+            type: 'array',
+            description: 'Per-key successful reads.',
+            items: {
+                type: 'object',
+                required: [
+                    'key',
+                    'data'
+                ],
+                properties: {
+                    key: {
+                        type: 'string'
+                    },
+                    data: {}
+                }
+            }
+        },
+        errors: {
+            type: 'array',
+            description: 'Per-key failures (not-found, forbidden, etc.).',
+            items: {
+                type: 'object',
+                required: [
+                    'key',
+                    'message'
+                ],
+                properties: {
+                    key: {
+                        type: 'string'
+                    },
+                    message: {
+                        type: 'string'
+                    },
+                    code: {
+                        type: 'string'
+                    }
+                }
+            }
+        }
+    }
+};
+
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$5(target, key, source[key]);
+        });
+    }
+    return target;
+}
+// MARK: Constants
+/**
+ * Reserved tool name for the built-in `model-info` static tool.
+ */ var MODEL_INFO_TOOL_NAME = 'model-info';
+/**
+ * Synthetic call type used in the tool's dispatch identity. Aligns with the dbx-cli `model-info`
+ * command.
+ */ var MODEL_INFO_DISPATCH_CALL = 'info';
+/**
+ * Synthetic model type used in the tool's dispatch identity. Mirrors {@link MODEL_GET_DISPATCH_MODEL_TYPE};
+ * apps avoiding collisions should not register a real model literally named "model".
+ */ var MODEL_INFO_DISPATCH_MODEL_TYPE = 'model';
+// MARK: Factory
+/**
+ * Builds the built-in `model-info` MCP tool definition.
+ *
+ * Mirrors dbx-cli's `model-info [model]` command:
+ * - Without a `model` arg: returns a summary list (modelType, modelName, prefix, group, identity, field count).
+ * - With a `model` arg: matches by `modelType`, `identityConst`, or `collectionPrefix` and returns the full entry.
+ *
+ * Output is delivered as both stringified JSON in `content[0].text` and `structuredContent`
+ * so MCP clients can consume either form.
+ *
+ * @param deps - The frozen model manifest loaded at boot from the MCP manifest JSON.
+ * @returns A statically-registered {@link McpToolDefinition} ready to be appended to the MCP
+ *   server factory's tool registry.
+ */ function createModelInfoTool(deps) {
+    var handler = function handler(args, ctx) {
+        return Promise.resolve(modelInfoToolHandler(args, ctx, deps));
+    };
+    var name = MODEL_INFO_TOOL_NAME;
+    var description = "Browse the Firestore model catalog (".concat(deps.manifest.length, " model").concat(deps.manifest.length === 1 ? '' : 's', "). Without `model`, returns a summary list of every model. With `model` (matched by modelType, identityConst, or collectionPrefix), returns the full entry with persisted fields.");
+    return {
+        name: name,
+        description: description,
+        inputSchema: MODEL_INFO_INPUT_SCHEMA,
+        outputSchema: MODEL_INFO_OUTPUT_SCHEMA,
+        dispatch: {
+            call: MODEL_INFO_DISPATCH_CALL,
+            modelType: MODEL_INFO_DISPATCH_MODEL_TYPE
+        },
+        staticHandler: handler,
+        filterMetadata: {
+            visibilityKind: 'declarative',
+            rule: {
+                requireAuthenticated: true
+            },
+            effectiveReadOnly: true
+        },
+        staticWireEntry: buildStaticWireEntry({
+            name: name,
+            description: description,
+            inputSchema: MODEL_INFO_INPUT_SCHEMA,
+            outputSchema: MODEL_INFO_OUTPUT_SCHEMA
+        })
+    };
+}
+// MARK: Handler
+function modelInfoToolHandler(args, _ctx, deps) {
+    var result;
+    try {
+        var input = parseModelInfoInput(args);
+        var output = input.model == null ? buildListOutput(deps.manifest) : buildSingleOutput(input.model, deps.manifest);
+        result = {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(output)
+                }
+            ],
+            structuredContent: output
+        };
+    } catch (error) {
+        result = formatMcpToolErrorResponse(error);
+    }
+    return result;
+}
+function parseModelInfoInput(args) {
+    var raw = args['model'];
+    var model;
+    if (raw == null) {
+        model = undefined;
+    } else if (typeof raw === 'string') {
+        var trimmed = raw.trim();
+        if (trimmed.length === 0) {
+            throw new Error('model-info: "model" must be a non-empty string when provided.');
+        }
+        model = trimmed;
+    } else {
+        throw new TypeError('model-info: "model" must be a string when provided.');
+    }
+    return {
+        model: model
+    };
+}
+function buildListOutput(manifest) {
+    var models = manifest.map(function(entry) {
+        var row = _object_spread$2({
+            modelType: entry.modelType,
+            modelName: entry.modelName,
+            identityConst: entry.identityConst,
+            collectionPrefix: entry.collectionPrefix,
+            sourcePackage: entry.sourcePackage,
+            fieldCount: entry.fields.length
+        }, entry.modelGroup == null ? {} : {
+            modelGroup: entry.modelGroup
+        }, entry.parentIdentityConst == null ? {} : {
+            parentIdentityConst: entry.parentIdentityConst
+        }, entry.description == null ? {} : {
+            description: entry.description
+        }, entry.read == null ? {} : {
+            read: entry.read
+        }, entry.serviceFactory == null ? {} : {
+            serviceFactoryExport: entry.serviceFactory.exportName
+        });
+        return row;
+    });
+    return {
+        mode: 'list',
+        models: models
+    };
+}
+function buildSingleOutput(query, manifest) {
+    var entry = findModelEntry(query, manifest);
+    if (entry == null) {
+        throw new Error('model-info: no model matches "'.concat(query, '". Call `model-info` without arguments to list available models.'));
+    }
+    return {
+        mode: 'single',
+        model: entry
+    };
+}
+/**
+ * Resolves a manifest entry by `modelType`, `identityConst`, or `collectionPrefix`.
+ *
+ * @param query - Identifier to look up.
+ * @param manifest - Model manifest to search.
+ * @returns The matching entry or `undefined`.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function findModelEntry(query, manifest) {
+    var result;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = manifest[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var entry = _step.value;
+            if (entry.modelType === query || entry.identityConst === query || entry.collectionPrefix === query) {
+                result = entry;
+                break;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+// MARK: Schemas
+var MODEL_INFO_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        model: {
+            type: 'string',
+            minLength: 1,
+            description: 'Model to inspect (modelType, identityConst, or collectionPrefix). Omit to list every model.'
+        }
+    },
+    additionalProperties: false
+};
+// MCP's `tools/list` validator requires `outputSchema.type === 'object'` at the root
+// (see @modelcontextprotocol/sdk Zod schema), so the list/single union is expressed via a
+// top-level object whose nested `oneOf` discriminates by the `mode` literal.
+var MODEL_INFO_OUTPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'mode'
+    ],
+    description: 'Either lists every model in the manifest (when `model` is omitted) or returns a full entry for the requested model (when `model` is provided). The `mode` field discriminates the variant.',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: [
+                'list',
+                'single'
+            ]
+        },
+        models: {
+            type: 'array',
+            description: 'Present when `mode` is `"list"`. One summary entry per registered model.',
+            items: {
+                type: 'object',
+                required: [
+                    'modelType',
+                    'modelName',
+                    'identityConst',
+                    'collectionPrefix',
+                    'sourcePackage',
+                    'fieldCount'
+                ],
+                properties: {
+                    modelType: {
+                        type: 'string'
+                    },
+                    modelName: {
+                        type: 'string'
+                    },
+                    modelGroup: {
+                        type: 'string'
+                    },
+                    identityConst: {
+                        type: 'string'
+                    },
+                    collectionPrefix: {
+                        type: 'string'
+                    },
+                    parentIdentityConst: {
+                        type: 'string'
+                    },
+                    sourcePackage: {
+                        type: 'string'
+                    },
+                    fieldCount: {
+                        type: 'integer'
+                    },
+                    description: {
+                        type: 'string'
+                    },
+                    read: {
+                        type: 'string',
+                        enum: [
+                            'system',
+                            'owner',
+                            'admin-only',
+                            'permissions'
+                        ]
+                    },
+                    serviceFactoryExport: {
+                        type: 'string'
+                    }
+                }
+            }
+        },
+        model: {
+            type: 'object',
+            description: 'Present when `mode` is `"single"`. The full manifest entry for the requested model.',
+            required: [
+                'modelType',
+                'modelName',
+                'identityConst',
+                'collectionPrefix',
+                'sourcePackage',
+                'sourceFile',
+                'fields'
+            ],
+            properties: {
+                modelType: {
+                    type: 'string'
+                },
+                modelName: {
+                    type: 'string'
+                },
+                modelGroup: {
+                    type: 'string'
+                },
+                identityConst: {
+                    type: 'string'
+                },
+                collectionPrefix: {
+                    type: 'string'
+                },
+                parentIdentityConst: {
+                    type: 'string'
+                },
+                description: {
+                    type: 'string'
+                },
+                sourcePackage: {
+                    type: 'string'
+                },
+                sourceFile: {
+                    type: 'string'
+                },
+                fields: {
+                    type: 'array',
+                    items: {
+                        type: 'object'
+                    }
+                },
+                read: {
+                    type: 'string',
+                    enum: [
+                        'system',
+                        'owner',
+                        'admin-only',
+                        'permissions'
+                    ]
+                },
+                serviceFactory: {
+                    type: 'object',
+                    required: [
+                        'exportName',
+                        'sourceFile'
+                    ],
+                    properties: {
+                        exportName: {
+                            type: 'string'
+                        },
+                        sourceFile: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        }
+    },
+    oneOf: [
+        {
+            required: [
+                'models'
+            ],
+            properties: {
+                mode: {
+                    const: 'list'
+                }
+            }
+        },
+        {
+            required: [
+                'model'
+            ],
+            properties: {
+                mode: {
+                    const: 'single'
+                }
+            }
+        }
+    ]
+};
+
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$4(target, key, source[key]);
+        });
+    }
+    return target;
+}
+// MARK: Constants
+/**
+ * Reserved tool name for the built-in `model-decode` static tool.
+ */ var MODEL_DECODE_TOOL_NAME = 'model-decode';
+/**
+ * Synthetic call type used in the tool's dispatch identity. Aligns with the dbx-cli `model-decode`
+ * command.
+ */ var MODEL_DECODE_DISPATCH_CALL = 'decode';
+/**
+ * Synthetic model type used in the tool's dispatch identity. Mirrors the other built-in static
+ * tools (`model-get`, `model-info`); apps avoiding collisions should not register a real model
+ * literally named "model".
+ */ var MODEL_DECODE_DISPATCH_MODEL_TYPE = 'model';
+// MARK: Factory
+/**
+ * Builds the built-in `model-decode` MCP tool definition.
+ *
+ * Mirrors dbx-cli's `model-decode <key>` command:
+ * - Splits the supplied Firestore key on `/`, walks `[prefix, id]` pairs, and resolves each prefix
+ *   against the manifest.
+ * - Supports subcollection paths (`parentPrefix/parentId/childPrefix/childId`).
+ *
+ * Output is delivered as both stringified JSON in `content[0].text` and `structuredContent` so
+ * MCP clients can consume either form.
+ *
+ * @param deps - The frozen model manifest loaded at boot from the MCP manifest JSON.
+ * @returns A statically-registered {@link McpToolDefinition} ready to be appended to the MCP
+ *   server factory's tool registry.
+ */ function createModelDecodeTool(deps) {
+    var handler = function handler(args, ctx) {
+        return Promise.resolve(modelDecodeToolHandler(args, ctx, deps));
+    };
+    var name = MODEL_DECODE_TOOL_NAME;
+    var description = 'Decode a Firestore model key ("prefix/id", or subcollection path "parentPrefix/parentId/childPrefix/childId") into { leaf, ancestors, unresolvedPrefixes } using the registered manifest ('.concat(deps.manifest.length, " model").concat(deps.manifest.length === 1 ? '' : 's', ").");
+    return {
+        name: name,
+        description: description,
+        inputSchema: MODEL_DECODE_INPUT_SCHEMA,
+        outputSchema: MODEL_DECODE_OUTPUT_SCHEMA,
+        dispatch: {
+            call: MODEL_DECODE_DISPATCH_CALL,
+            modelType: MODEL_DECODE_DISPATCH_MODEL_TYPE
+        },
+        staticHandler: handler,
+        filterMetadata: {
+            visibilityKind: 'declarative',
+            rule: {
+                requireAuthenticated: true
+            },
+            effectiveReadOnly: true
+        },
+        staticWireEntry: buildStaticWireEntry({
+            name: name,
+            description: description,
+            inputSchema: MODEL_DECODE_INPUT_SCHEMA,
+            outputSchema: MODEL_DECODE_OUTPUT_SCHEMA
+        })
+    };
+}
+// MARK: Handler
+function modelDecodeToolHandler(args, _ctx, deps) {
+    var result;
+    try {
+        var input = parseModelDecodeInput(args);
+        var output = decodeFirestoreModelKey(input.key, deps.manifest);
+        result = {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(output)
+                }
+            ],
+            structuredContent: output
+        };
+    } catch (error) {
+        result = formatMcpToolErrorResponse(error);
+    }
+    return result;
+}
+function parseModelDecodeInput(args) {
+    var raw = args['key'];
+    if (typeof raw !== 'string' || raw.length === 0) {
+        throw new Error('model-decode: "key" is required and must be a non-empty string.');
+    }
+    return {
+        key: raw
+    };
+}
+/**
+ * Splits `rawKey` on `/`, resolves each `[prefix, id]` pair against the manifest, and
+ * returns the leaf segment + ancestor chain.
+ *
+ * Mirrors the dbx-cli `decodeFirestoreModelKey` helper structurally; both implementations
+ * must stay in lockstep on segment count and resolution order.
+ *
+ * @param rawKey - The Firestore key string.
+ * @param manifest - The model manifest.
+ * @returns The decoded key with leaf, ancestors, and any unresolved prefixes.
+ * @throws {Error} When `rawKey` is empty or does not parse into an even number of `prefix/id` segments.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function decodeFirestoreModelKey(rawKey, manifest) {
+    var trimmed = rawKey.trim();
+    if (trimmed.length === 0) {
+        throw new Error('model-decode: key is empty. Provide a Firestore key like `sf/abc123`.');
+    }
+    var segments = trimmed.split('/').filter(function(s) {
+        return s.length > 0;
+    });
+    if (segments.length < 2 || segments.length % 2 !== 0) {
+        throw new Error('model-decode: invalid Firestore key "'.concat(trimmed, '". Expected an even number of segments (`prefix/id` pairs). Got ').concat(segments.length, " segment(s). Use the format `prefix/id` (or `parentPrefix/parentId/childPrefix/childId` for subcollections)."));
+    }
+    var decoded = [];
+    var unresolved = [];
+    for(var i = 0; i < segments.length; i += 2){
+        var prefix = segments[i];
+        var id = segments[i + 1];
+        var entry = findModelEntry(prefix, manifest);
+        if (entry == null) {
+            unresolved.push(prefix);
+        }
+        decoded.push(toSegment(prefix, id, entry));
+    }
+    var leaf = decoded.at(-1);
+    var ancestors = decoded.slice(0, -1);
+    return {
+        key: trimmed,
+        leaf: leaf,
+        ancestors: ancestors,
+        unresolvedPrefixes: unresolved
+    };
+}
+function toSegment(prefix, id, entry) {
+    var segment = entry ? _object_spread$1({
+        prefix: prefix,
+        id: id,
+        modelType: entry.modelType,
+        modelName: entry.modelName,
+        identityConst: entry.identityConst,
+        sourcePackage: entry.sourcePackage,
+        sourceFile: entry.sourceFile
+    }, entry.modelGroup == null ? {} : {
+        modelGroup: entry.modelGroup
+    }, entry.parentIdentityConst == null ? {} : {
+        parentIdentityConst: entry.parentIdentityConst
+    }) : {
+        prefix: prefix,
+        id: id
+    };
+    return segment;
+}
+// MARK: Schemas
+var MODEL_DECODE_INPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'key'
+    ],
+    properties: {
+        key: {
+            type: 'string',
+            minLength: 1,
+            description: 'Firestore model key — prefix/id, or `parentPrefix/parentId/childPrefix/childId` for subcollections.'
+        }
+    },
+    additionalProperties: false
+};
+var SEGMENT_SCHEMA = {
+    type: 'object',
+    required: [
+        'prefix',
+        'id'
+    ],
+    properties: {
+        prefix: {
+            type: 'string'
+        },
+        id: {
+            type: 'string'
+        },
+        modelType: {
+            type: 'string'
+        },
+        modelName: {
+            type: 'string'
+        },
+        modelGroup: {
+            type: 'string'
+        },
+        identityConst: {
+            type: 'string'
+        },
+        parentIdentityConst: {
+            type: 'string'
+        },
+        sourcePackage: {
+            type: 'string'
+        },
+        sourceFile: {
+            type: 'string'
+        }
+    }
+};
+var MODEL_DECODE_OUTPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'key',
+        'leaf',
+        'ancestors',
+        'unresolvedPrefixes'
+    ],
+    properties: {
+        key: {
+            type: 'string',
+            description: 'The trimmed input key.'
+        },
+        leaf: SEGMENT_SCHEMA,
+        ancestors: {
+            type: 'array',
+            description: 'Parent segments, root-first.',
+            items: SEGMENT_SCHEMA
+        },
+        unresolvedPrefixes: {
+            type: 'array',
+            description: 'Prefixes that did not match any model in the manifest.',
+            items: {
+                type: 'string'
+            }
+        }
+    }
+};
+
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$1(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$2(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit$1(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread$2() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$3(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest$1();
+}
+function _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$2();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+// MARK: Constants
+/**
+ * Reserved tool name for the built-in `whoami` static tool.
+ */ var WHOAMI_TOOL_NAME = 'whoami';
+/**
+ * Synthetic call type used in the tool's dispatch identity. Matches the
+ * pattern set by `model-info` — `read` (not `info`) so the visibility
+ * classifier treats the tool as a read.
+ */ var WHOAMI_DISPATCH_CALL = 'read';
+/**
+ * Synthetic model type used in the tool's dispatch identity.
+ */ var WHOAMI_DISPATCH_MODEL_TYPE = 'auth';
+// MARK: Factory
+/**
+ * Builds the built-in `whoami` MCP tool definition. Returns the calling
+ * caller's `uid`, claims object, decoded role set, and rendered descriptions
+ * for every claim key actually present on the live token.
+ *
+ * Unauthenticated callers receive a structured `authenticated: false` result
+ * (no exception) so the tool can be used as a "do you see me?" probe.
+ *
+ * @param deps - The manifest's auth section + optional role reader.
+ * @returns A statically-registered {@link McpToolDefinition} to append to the MCP server factory's tool registry.
+ */ function createWhoamiTool(deps) {
+    var _ref;
+    var _deps_auth_app;
+    var handler = function handler(_args, ctx) {
+        return Promise.resolve(whoamiToolHandler(ctx, deps));
+    };
+    var name = WHOAMI_TOOL_NAME;
+    var appLabel = (_ref = (_deps_auth_app = deps.auth.app) === null || _deps_auth_app === void 0 ? void 0 : _deps_auth_app.app) !== null && _ref !== void 0 ? _ref : 'this server';
+    var description = "Reports the authenticated caller's uid, raw custom claims, and decoded role set for `".concat(appLabel, "`. Returns `authenticated: false` for anonymous callers. Claim descriptions are drawn from the build-time auth manifest; only keys actually present on the live token are detailed.");
+    return {
+        name: name,
+        description: description,
+        inputSchema: WHOAMI_INPUT_SCHEMA,
+        outputSchema: WHOAMI_OUTPUT_SCHEMA,
+        dispatch: {
+            call: WHOAMI_DISPATCH_CALL,
+            modelType: WHOAMI_DISPATCH_MODEL_TYPE
+        },
+        staticHandler: handler,
+        filterMetadata: {
+            visibilityKind: 'declarative',
+            rule: {},
+            effectiveReadOnly: true
+        },
+        staticWireEntry: buildStaticWireEntry({
+            name: name,
+            description: description,
+            inputSchema: WHOAMI_INPUT_SCHEMA,
+            outputSchema: WHOAMI_OUTPUT_SCHEMA
+        })
+    };
+}
+// MARK: Handler
+function whoamiToolHandler(ctx, deps) {
+    var _auth_token;
+    var _deps_auth_app;
+    var auth = ctx.auth;
+    if ((auth === null || auth === void 0 ? void 0 : auth.uid) == null) {
+        var output = {
+            authenticated: false,
+            claims: {},
+            roles: [],
+            claimDetails: [],
+            unknownClaimKeys: []
+        };
+        return buildResult(output, '# whoami\n\nUnauthenticated.');
+    }
+    var token = (_auth_token = auth.token) !== null && _auth_token !== void 0 ? _auth_token : {};
+    var presentKeys = Object.entries(token).filter(function(param) {
+        var _param = _sliced_to_array$1(param, 2), value = _param[1];
+        return value !== undefined;
+    }).map(function(param) {
+        var _param = _sliced_to_array$1(param, 1), key = _param[0];
+        return key;
+    });
+    var roleSet = deps.roleReader == null ? new Set() : deps.roleReader(token);
+    var roles = _to_consumable_array$2(roleSet).sort(function(a, b) {
+        return a.localeCompare(b);
+    });
+    var claimsByKey = new Map();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = deps.auth.claims[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var claim = _step.value;
+            claimsByKey.set(claim.key, claim);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var claimDetails = [];
+    var unknownClaimKeys = [];
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+    try {
+        for(var _iterator1 = presentKeys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var key = _step1.value;
+            if (key === 'email' || key === 'email_verified') {
+                continue;
+            }
+            var claim1 = claimsByKey.get(key);
+            if (claim1 == null) {
+                unknownClaimKeys.push(key);
+            } else {
+                claimDetails.push(_object_spread({
+                    key: claim1.key,
+                    description: claim1.description,
+                    grantedRoles: claim1.mapping.roles,
+                    inverse: claim1.mapping.inverse,
+                    tags: claim1.tags
+                }, claim1.interfaceName == null ? {} : {
+                    interfaceName: claim1.interfaceName
+                }));
+            }
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
+        }
+    }
+    var output1 = _object_spread({
+        authenticated: true,
+        uid: auth.uid,
+        claims: _object_spread({}, token),
+        roles: roles,
+        claimDetails: claimDetails,
+        unknownClaimKeys: unknownClaimKeys
+    }, ((_deps_auth_app = deps.auth.app) === null || _deps_auth_app === void 0 ? void 0 : _deps_auth_app.app) == null ? {} : {
+        app: deps.auth.app.app
+    }, token.email == null ? {} : {
+        email: token.email
+    }, token.email_verified == null ? {} : {
+        emailVerified: token.email_verified
+    });
+    var text = renderText(output1);
+    return buildResult(output1, text);
+}
+function buildResult(output, text) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: text
+            }
+        ],
+        structuredContent: output
+    };
+}
+function renderText(output) {
+    var lines = [
+        '# whoami',
+        ''
+    ];
+    appendHeaderLines(lines, output);
+    appendClaimDetailLines(lines, output.claimDetails);
+    appendUnknownClaimLines(lines, output.unknownClaimKeys);
+    return lines.join('\n');
+}
+function appendHeaderLines(lines, output) {
+    if (output.uid != null) {
+        lines.push("- **uid:** `".concat(output.uid, "`"));
+    }
+    if (output.app != null) {
+        lines.push("- **app:** `".concat(output.app, "`"));
+    }
+    if (output.email != null) {
+        lines.push("- **email:** `".concat(output.email, "`"));
+    }
+    if (output.roles.length > 0) {
+        var rolesText = output.roles.map(function(role) {
+            return "`".concat(role, "`");
+        }).join(', ');
+        lines.push("- **roles:** ".concat(rolesText));
+    } else {
+        lines.push('- **roles:** _(none)_');
+    }
+}
+function appendClaimDetailLines(lines, claimDetails) {
+    if (claimDetails.length === 0) {
+        return;
+    }
+    lines.push('', '## Claims on this token');
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = claimDetails[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var detail = _step.value;
+            var headerInterfacePart = detail.interfaceName == null ? '' : " on `".concat(detail.interfaceName, "`");
+            var grants = detail.grantedRoles.length > 0 ? detail.grantedRoles.map(function(role) {
+                return "`".concat(role, "`");
+            }).join(', ') : '_(no roles)_';
+            var action = detail.inverse ? 'revokes' : 'grants';
+            lines.push("- `".concat(detail.key, "`").concat(headerInterfacePart, " — ").concat(action, " ").concat(grants));
+            if (detail.description.length > 0) {
+                lines.push("  ".concat(detail.description));
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+function appendUnknownClaimLines(lines, unknownClaimKeys) {
+    if (unknownClaimKeys.length === 0) {
+        return;
+    }
+    lines.push('', '## Unknown claim keys');
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = unknownClaimKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            lines.push("- `".concat(key, "`"));
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+// MARK: Schemas
+var WHOAMI_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false
+};
+var WHOAMI_OUTPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'authenticated',
+        'claims',
+        'roles',
+        'claimDetails',
+        'unknownClaimKeys'
+    ],
+    description: 'Caller identity, raw token claims, decoded role set, and per-claim descriptions for every key present on the live token.',
+    properties: {
+        authenticated: {
+            type: 'boolean'
+        },
+        uid: {
+            type: 'string'
+        },
+        email: {
+            type: 'string'
+        },
+        emailVerified: {
+            type: 'boolean'
+        },
+        app: {
+            type: 'string'
+        },
+        claims: {
+            type: 'object',
+            additionalProperties: true
+        },
+        roles: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        claimDetails: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: [
+                    'key',
+                    'description',
+                    'grantedRoles',
+                    'inverse',
+                    'tags'
+                ],
+                properties: {
+                    key: {
+                        type: 'string'
+                    },
+                    interfaceName: {
+                        type: 'string'
+                    },
+                    description: {
+                        type: 'string'
+                    },
+                    grantedRoles: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    inverse: {
+                        type: 'boolean'
+                    },
+                    tags: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        },
+        unknownClaimKeys: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        }
+    }
+};
+
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$2(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread$1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var McpServerFactoryService_1;
+/**
+ * Injectable factory that builds {@link McpServer} instances pre-wired to the
+ * call model dispatch chain.
+ *
+ * The factory is invoked per Streamable HTTP request — `@modelcontextprotocol/sdk`
+ * recommends a fresh `McpServer` + transport pair per stateless JSON-RPC request,
+ * which sidesteps session bookkeeping for the common Claude-connector case.
+ */ exports.McpServerFactoryService = McpServerFactoryService_1 = /*#__PURE__*/ function() {
+    function McpServerFactoryService(mcpConfig, dispatchService, modelApiGetService, roleReader) {
+        _class_call_check$2(this, McpServerFactoryService);
+        _define_property$2(this, "mcpConfig", void 0);
+        _define_property$2(this, "dispatchService", void 0);
+        _define_property$2(this, "modelApiGetService", void 0);
+        _define_property$2(this, "roleReader", void 0);
+        _define_property$2(this, "_logger", new common.Logger(McpServerFactoryService_1.name));
+        _define_property$2(this, "_cachedTools", void 0);
+        _define_property$2(this, "_cachedStaticTools", void 0);
+        _define_property$2(this, "_cachedManifest", void 0);
+        _define_property$2(this, "_cachedManifestModels", void 0);
+        _define_property$2(this, "_cachedManifestAuth", void 0);
+        _define_property$2(this, "_manifestLoaded", false);
+        _define_property$2(this, "_loggedSkips", false);
+        _define_property$2(this, "_warnedMissingRoleReader", false);
+        this.mcpConfig = mcpConfig;
+        this.dispatchService = dispatchService;
+        this.modelApiGetService = modelApiGetService;
+        this.roleReader = roleReader;
+    }
+    _create_class$2(McpServerFactoryService, [
+        {
+            /**
+     * Builds a configured MCP server with tool listing + dispatch handlers wired up.
+     *
+     * @param ctx - The per-request context (auth, raw request) used when forwarding tool calls.
+     * @returns A configured MCP server ready to be `connect()`-ed to a transport.
+     */ key: "createServer",
+            value: function createServer(ctx) {
+                var _this = this;
+                var _this_mcpConfig_serverName, _this_mcpConfig_serverVersion;
+                var baseServerName = (_this_mcpConfig_serverName = this.mcpConfig.serverName) !== null && _this_mcpConfig_serverName !== void 0 ? _this_mcpConfig_serverName : DEFAULT_MCP_SERVER_NAME;
+                var serverName = this.mcpConfig.readOnly === true ? "".concat(baseServerName, " (read-only)") : baseServerName;
+                var server = new mcp_js.McpServer({
+                    name: serverName,
+                    version: (_this_mcpConfig_serverVersion = this.mcpConfig.serverVersion) !== null && _this_mcpConfig_serverVersion !== void 0 ? _this_mcpConfig_serverVersion : '0.0.0'
+                }, {
+                    instructions: 'Model-bound RPC tools generated from the callModel _apiDetails tree.'
+                });
+                server.server.registerCapabilities({
+                    tools: {}
+                });
+                var toolGeneration = this._resolveToolDefinitions();
+                var staticTools = this._resolveStaticTools();
+                var scopes = this._resolveScopes(ctx);
+                var authRoles = this._resolveAuthRoles(ctx);
+                var combinedTools = _to_consumable_array$1(toolGeneration.tools).concat(_to_consumable_array$1(staticTools));
+                var visibleTools = this._filterToolsForRequest(combinedTools, {
+                    ctx: ctx,
+                    scopes: scopes,
+                    authRoles: authRoles
+                });
+                var definitionsByName = new Map(visibleTools.map(function(tool) {
+                    return [
+                        tool.name,
+                        tool
+                    ];
+                }));
+                server.server.setRequestHandler(types_js.ListToolsRequestSchema, function() {
+                    return _async_to_generator$2(function() {
+                        var _this;
+                        return _ts_generator$2(this, function(_state) {
+                            _this = this;
+                            return [
+                                2,
+                                {
+                                    tools: visibleTools.map(function(tool) {
+                                        return _this._buildToolListEntry(tool, ctx, scopes);
+                                    })
+                                }
+                            ];
+                        });
+                    }).call(_this);
+                });
+                server.server.setRequestHandler(types_js.CallToolRequestSchema, function(request) {
+                    return _async_to_generator$2(function() {
+                        return _ts_generator$2(this, function(_state) {
+                            return [
+                                2,
+                                this._handleToolCall(request, definitionsByName, ctx)
+                            ];
+                        });
+                    }).call(_this);
+                });
+                return server;
+            }
+        },
+        {
+            /**
+     * Reads cached tool definitions, regenerating + logging skips on first call.
+     *
+     * The underlying call model `_apiDetails` is built at boot and doesn't change at runtime,
+     * so the generation result is safe to cache for the lifetime of the process.
+     *
+     * @returns The cached or freshly-generated tool generation result.
+     */ key: "_resolveToolDefinitions",
+            value: function _resolveToolDefinitions() {
+                var result = this._cachedTools;
+                if (result == null) {
+                    var apiDetails = this.dispatchService.getApiDetails();
+                    var manifest = this._resolveManifest();
+                    if (apiDetails == null) {
+                        result = {
+                            tools: [],
+                            neverVisibleTools: [],
+                            skipped: []
+                        };
+                    } else {
+                        result = generateMcpToolDefinitions(apiDetails, undefined, manifest);
+                    }
+                    this._cachedTools = result;
+                }
+                if (!this._loggedSkips && result.skipped.length > 0) {
+                    this._loggedSkips = true;
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = result.skipped[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var skip = _step.value;
+                            var errorSuffix = skip.error ? ": ".concat(skip.error.message) : '';
+                            this._logger.warn("Skipped MCP tool ".concat(skip.toolName, " (").concat(skip.reason, ")").concat(errorSuffix));
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                }
+                return result;
+            }
+        },
+        {
+            /**
+     * Builds the list of statically-registered (non-callModel) MCP tools.
+     *
+     * Includes `model-get` whenever {@link ModelApiGetService} is available, plus
+     * `model-info` and `model-decode` whenever the boot-time MCP manifest provided
+     * a non-empty `models` catalog. The list is cached for the lifetime of the
+     * process since static tools share the same boot-time inputs as the
+     * auto-generated ones.
+     *
+     * @returns The cached array of static tool definitions, filtered for collisions with generated tools.
+     */ key: "_resolveStaticTools",
+            value: function _resolveStaticTools() {
+                var result = this._cachedStaticTools;
+                if (result == null) {
+                    var _ref;
+                    var _this__cachedTools;
+                    // Ensure the manifest has been loaded so its `models` array is available for the catalog tools.
+                    this._resolveManifest();
+                    var staticTools = [];
+                    var getService = this.modelApiGetService;
+                    if (getService != null) {
+                        staticTools.push(createModelGetTool({
+                            readDocuments: function readDocuments(modelType, keys, auth) {
+                                return getService.readDocuments(modelType, keys, auth);
+                            },
+                            resolveIdentity: function resolveIdentity(modelType, auth) {
+                                return getService.getModelIdentity(modelType, auth);
+                            }
+                        }));
+                    }
+                    var modelManifest = this._cachedManifestModels;
+                    if (modelManifest != null && modelManifest.length > 0) {
+                        staticTools.push(createModelInfoTool({
+                            manifest: modelManifest
+                        }), createModelDecodeTool({
+                            manifest: modelManifest
+                        }));
+                    }
+                    var authManifest = this._cachedManifestAuth;
+                    if (authManifest != null) {
+                        staticTools.push(createWhoamiTool({
+                            auth: authManifest,
+                            roleReader: this.roleReader
+                        }));
+                    }
+                    // Guard against the auto-generated tools accidentally claiming a static tool name. The first
+                    // dispatch wins via Map.set order, so a collision would silently shadow one side.
+                    var generatedNames = new Set((_ref = (_this__cachedTools = this._cachedTools) === null || _this__cachedTools === void 0 ? void 0 : _this__cachedTools.tools.map(function(t) {
+                        return t.name;
+                    })) !== null && _ref !== void 0 ? _ref : []);
+                    var filtered = [];
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = staticTools[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var tool = _step.value;
+                            if (generatedNames.has(tool.name)) {
+                                this._logger.warn('Static MCP tool "'.concat(tool.name, '" collides with an auto-generated tool of the same name; the auto-generated tool will win.'));
+                            } else {
+                                filtered.push(tool);
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    result = filtered;
+                    this._cachedStaticTools = result;
+                }
+                return result;
+            }
+        },
+        {
+            /**
+     * Reads the pre-rendered MCP manifest JSON once, validates its version, and caches the
+     * resulting `key → entry` map plus the optional `models` catalog for the process lifetime.
+     *
+     * Missing file or wrong version fall back to "no manifest" with a single boot warning;
+     * the runtime still produces tools using the auto-generated descriptions and
+     * ArkType-derived schemas.
+     *
+     * @returns The cached tool-entry map, or `undefined` when no manifest was loaded.
+     */ key: "_resolveManifest",
+            value: function _resolveManifest() {
+                if (!this._manifestLoaded) {
+                    this._manifestLoaded = true;
+                    var path = this.mcpConfig.mcpManifestPath;
+                    if (path == null) {
+                        this._resetManifestCache();
+                    } else if (node_fs.existsSync(path)) {
+                        this._parseManifestFile(path);
+                    } else {
+                        this._logger.warn("MCP manifest path is set but the file is missing: ".concat(path, ". Falling back to runtime defaults."));
+                        this._resetManifestCache();
+                    }
+                }
+                return this._cachedManifest;
+            }
+        },
+        {
+            key: "_resetManifestCache",
+            value: function _resetManifestCache() {
+                this._cachedManifest = undefined;
+                this._cachedManifestModels = undefined;
+                this._cachedManifestAuth = undefined;
+            }
+        },
+        {
+            key: "_parseManifestFile",
+            value: function _parseManifestFile(path) {
+                try {
+                    var raw = node_fs.readFileSync(path, 'utf8');
+                    var parsed = JSON.parse(raw);
+                    if (parsed.version === MCP_MANIFEST_VERSION) {
+                        this._applyParsedManifest(parsed, path);
+                    } else {
+                        this._logger.warn("MCP manifest version mismatch at ".concat(path, ": got ").concat(String(parsed.version), ", expected ").concat(MCP_MANIFEST_VERSION, ". Falling back to runtime defaults."));
+                        this._resetManifestCache();
+                    }
+                } catch (error) {
+                    this._logger.warn("Failed to read MCP manifest at ".concat(path, ": ").concat(error.message, ". Falling back to runtime defaults."));
+                    this._resetManifestCache();
+                }
+            }
+        },
+        {
+            key: "_applyParsedManifest",
+            value: function _applyParsedManifest(parsed, path) {
+                var map = new Map();
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = Object.entries(parsed.tools)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], entry = _step_value[1];
+                        if (entry != null) {
+                            map.set(key, entry);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                var models = Array.isArray(parsed.models) && parsed.models.length > 0 ? parsed.models : undefined;
+                var modelSuffix = models == null ? '' : ", ".concat(models.length, " model entries");
+                var auth = parsed.auth != null && Array.isArray(parsed.auth.claims) ? parsed.auth : undefined;
+                var authSuffix = auth == null ? '' : ", ".concat(auth.claims.length, " auth claim entries");
+                this._logger.log("Loaded MCP manifest from ".concat(path, ": ").concat(map.size, " tool entries").concat(modelSuffix).concat(authSuffix, "."));
+                this._cachedManifest = map;
+                this._cachedManifestModels = models;
+                this._cachedManifestAuth = auth;
+            }
+        },
+        {
+            /**
+     * Reads the caller's OIDC scopes from the raw Express request via the auth context.
+     *
+     * Synthesizes the same `{ auth: { token } }` shape that `getOidcScopesFromRequest`
+     * expects post-dispatch, so the upstream helper stays the single source of scope parsing.
+     * Returns `undefined` for non-OIDC callers (no `oidcValidatedToken.scope`) — the filter
+     * loop treats that as "skip scope enforcement", matching `oidcCallModelScopePreAssert`.
+     *
+     * @param ctx - The per-request context carrying the validated auth payload.
+     * @returns The set of granted OIDC scopes, or `undefined` when scope enforcement should be skipped.
+     */ key: "_resolveScopes",
+            value: function _resolveScopes(ctx) {
+                var _ctx_auth;
+                var oidcValidatedToken = (_ctx_auth = ctx.auth) === null || _ctx_auth === void 0 ? void 0 : _ctx_auth.oidcValidatedToken;
+                return oidcValidatedToken == null ? undefined : oidc.getOidcScopesFromRequest({
+                    auth: {
+                        token: oidcValidatedToken
+                    }
+                });
+            }
+        },
+        {
+            /**
+     * Maps the caller's Firebase custom claims through the optional role reader.
+     * Emits one boot-time warning when a declarative `requiredRoles` rule will be checked
+     * but no reader is wired — that path will fail closed.
+     *
+     * @param ctx - The per-request context carrying the authenticated user's token.
+     * @returns The resolved auth role set, or `undefined` when no auth or reader is available.
+     */ key: "_resolveAuthRoles",
+            value: function _resolveAuthRoles(ctx) {
+                var _ctx_auth;
+                var result;
+                if (((_ctx_auth = ctx.auth) === null || _ctx_auth === void 0 ? void 0 : _ctx_auth.token) != null && this.roleReader != null) {
+                    result = this.roleReader(ctx.auth.token);
+                }
+                return result;
+            }
+        },
+        {
+            key: "_filterToolsForRequest",
+            value: function _filterToolsForRequest(tools, context) {
+                var ctx = context.ctx, scopes = context.scopes, authRoles = context.authRoles;
+                var readOnlyMode = this.mcpConfig.readOnly === true;
+                var visible = [];
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = tools[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var tool = _step.value;
+                        var filterMetadata = tool.filterMetadata;
+                        if (scopes != null && filterMetadata.requiredScope != null && !scopes.has(filterMetadata.requiredScope)) {
+                            continue;
+                        }
+                        if (readOnlyMode && filterMetadata.effectiveReadOnly !== true) {
+                            continue;
+                        }
+                        if (!this._passesVisibility({
+                            tool: tool,
+                            ctx: ctx,
+                            scopes: scopes,
+                            authRoles: authRoles
+                        })) {
+                            continue;
+                        }
+                        visible.push(tool);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return visible;
+            }
+        },
+        {
+            key: "_passesVisibility",
+            value: function _passesVisibility(input) {
+                var tool = input.tool, ctx = input.ctx, scopes = input.scopes, authRoles = input.authRoles;
+                var filterMetadata = tool.filterMetadata;
+                var result;
+                if (filterMetadata.visibilityKind === 'declarative') {
+                    result = this._checkDeclarativeVisibility(filterMetadata.rule, ctx, authRoles);
+                } else if (filterMetadata.visibilityKind === 'dynamic') {
+                    try {
+                        result = filterMetadata.visibilityFn({
+                            auth: ctx.auth,
+                            scopes: scopes !== null && scopes !== void 0 ? scopes : undefined,
+                            tool: tool.dispatch
+                        }) === true;
+                    } catch (error) {
+                        this._logger.warn("MCP tool ".concat(tool.name, " visibility predicate threw; treating as not visible: ").concat(error.message));
+                        result = false;
+                    }
+                } else {
+                    result = true;
+                }
+                return result;
+            }
+        },
+        {
+            key: "_checkDeclarativeVisibility",
+            value: function _checkDeclarativeVisibility(rule, ctx, authRoles) {
+                var result = true;
+                if (rule.requireAuthenticated === true && ctx.auth == null) {
+                    result = false;
+                } else if (rule.requiredRoles != null && rule.requiredRoles.length > 0) {
+                    if (authRoles == null) {
+                        if (this.roleReader == null && !this._warnedMissingRoleReader) {
+                            this._warnedMissingRoleReader = true;
+                            this._logger.warn('MCP tool visibility rule declared requiredRoles but no McpAuthRoleReader is provided. Tools gated by role will be hidden.');
+                        }
+                        result = false;
+                    } else {
+                        result = util.authRolesSetHasRoles(authRoles, rule.requiredRoles);
+                    }
+                }
+                return result;
+            }
+        },
+        {
+            /**
+     * Resolves the wire-shape `tools/list` entry for a single tool.
+     *
+     * Hot-path short-circuit: tools without a `toolDetailsBuilder` reuse the precomputed,
+     * frozen {@link McpToolDefinition.staticWireEntry} verbatim — zero allocations per
+     * request for the common case.
+     *
+     * Tools that opted in to {@link McpToolDetailsBuilder} get a fresh wire entry built
+     * from the builder's overrides. If the builder throws, the framework falls back to
+     * the static defaults and logs a warning (fail-soft, matching `_passesVisibility`).
+     *
+     * @param tool - The tool definition whose wire entry is being resolved.
+     * @param ctx - The per-request context forwarded to any dynamic details builder.
+     * @param scopes - The caller's granted OIDC scopes forwarded to any dynamic details builder.
+     * @returns The wire-shape entry to emit for this tool on `tools/list`.
+     */ key: "_buildToolListEntry",
+            value: function _buildToolListEntry(tool, ctx, scopes) {
+                var result;
+                if (tool.toolDetailsBuilder == null) {
+                    result = tool.staticWireEntry;
+                } else {
+                    var description = tool.description;
+                    var inputSchema = tool.inputSchema;
+                    try {
+                        var overrides = tool.toolDetailsBuilder({
+                            dispatch: tool.dispatch,
+                            defaultDescription: description,
+                            defaultInputSchema: inputSchema,
+                            auth: ctx.auth,
+                            scopes: scopes !== null && scopes !== void 0 ? scopes : undefined
+                        });
+                        if (overrides.description != null) {
+                            description = overrides.description;
+                        }
+                        if (overrides.inputSchema != null) {
+                            inputSchema = overrides.inputSchema;
+                        }
+                    } catch (error) {
+                        this._logger.warn("MCP tool ".concat(tool.name, " toolDetails builder threw; falling back to defaults: ").concat(error.message));
+                    }
+                    var wire = {
+                        name: tool.name,
+                        description: description,
+                        inputSchema: inputSchema !== null && inputSchema !== void 0 ? inputSchema : {
+                            type: 'object'
+                        }
+                    };
+                    if (tool.outputSchema != null) {
+                        wire.outputSchema = tool.outputSchema;
+                    }
+                    result = wire;
+                }
+                return result;
+            }
+        },
+        {
+            key: "_handleToolCall",
+            value: function _handleToolCall(request, definitionsByName, ctx) {
+                return _async_to_generator$2(function() {
+                    var _request_params_arguments, definition, args, response;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                definition = definitionsByName.get(request.params.name);
+                                args = (_request_params_arguments = request.params.arguments) !== null && _request_params_arguments !== void 0 ? _request_params_arguments : {};
+                                if (!(definition == null)) return [
+                                    3,
+                                    1
+                                ];
+                                response = formatMcpToolErrorResponse(new Error("Unknown tool: ".concat(request.params.name)));
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 1:
+                                if (!(definition.staticHandler == null)) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    this._handleCallModelToolCall(definition, args, ctx)
+                                ];
+                            case 2:
+                                response = _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 3:
+                                return [
+                                    4,
+                                    this._handleStaticToolCall(definition.staticHandler, args, ctx)
+                                ];
+                            case 4:
+                                response = _state.sent();
+                                _state.label = 5;
+                            case 5:
+                                return [
+                                    2,
+                                    response
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "_handleStaticToolCall",
+            value: function _handleStaticToolCall(staticHandler, args, ctx) {
+                return _async_to_generator$2(function() {
+                    var response, error;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                return [
+                                    4,
+                                    staticHandler(args, ctx)
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 2:
+                                error = _state.sent();
+                                response = formatMcpToolErrorResponse(error);
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 3:
+                                return [
+                                    2,
+                                    response
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "_handleCallModelToolCall",
+            value: function _handleCallModelToolCall(definition, args, ctx) {
+                return _async_to_generator$2(function() {
+                    var params, response, result, error;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                params = {
+                                    call: definition.dispatch.call,
+                                    modelType: definition.dispatch.modelType,
+                                    specifier: definition.dispatch.specifier,
+                                    data: args
+                                };
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    this.dispatchService.dispatch(params, ctx.auth, ctx.rawRequest)
+                                ];
+                            case 2:
+                                result = _state.sent();
+                                response = formatMcpToolResponse(result, params, definition.details);
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                response = formatMcpToolErrorResponse(error);
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
+                                return [
+                                    2,
+                                    response
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return McpServerFactoryService;
+}();
+exports.McpServerFactoryService = McpServerFactoryService_1 = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(McpModuleConfig)),
+    __param(1, common.Inject(firebaseServer.ModelApiCallModelDispatchService)),
+    __param(2, common.Optional()),
+    __param(2, common.Inject(firebaseServer.ModelApiGetService)),
+    __param(3, common.Optional()),
+    __param(3, common.Inject(MCP_AUTH_ROLE_READER))
+], exports.McpServerFactoryService);
+
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Handles a single Streamable HTTP JSON-RPC request against the supplied MCP server.
+ *
+ * Each call creates a fresh `StreamableHTTPServerTransport` in stateless mode — the
+ * transport binds the server, processes one request, and is discarded. Stateless
+ * mode is adequate for Claude custom-connector usage and avoids the bookkeeping
+ * cost of session-tracked transports for the common case.
+ *
+ * The caller is expected to have already validated the bearer token (via the
+ * OIDC bearer middleware) before this function runs.
+ *
+ * @param req - The Express request carrying the JSON-RPC body.
+ * @param res - The Express response.
+ * @param server - The MCP server instance to back the transport.
+ * @param server.connect - The MCP server's connect method that binds the transport before request handling.
+ */ function handleStreamableHttpMcpRequest(req, res, server) {
+    return _async_to_generator$1(function() {
+        var transport;
+        return _ts_generator$1(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    // sessionIdGenerator: undefined → stateless mode.
+                    transport = new streamableHttp_js.StreamableHTTPServerTransport({
+                        sessionIdGenerator: undefined
+                    });
+                    res.on('close', function() {
+                        void transport.close();
+                    });
+                    return [
+                        4,
+                        server.connect(transport)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        4,
+                        transport.handleRequest(req, res, req.body)
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var McpController_1;
+/**
+ * NestJS controller mounting the MCP Streamable HTTP transport at `POST /mcp`.
+ *
+ * Auth is enforced by the global OIDC bearer middleware (`OidcAuthBearerTokenMiddleware`)
+ * which must include `'/mcp'` in its `protectedPaths`. By the time the request reaches
+ * this controller, `req.auth` is populated with the authenticated user's data.
+ *
+ * Each request gets a fresh transport + MCP server pair (stateless mode), which is
+ * adequate for Claude custom-connector style usage. A session-tracked variant can
+ * be layered on later if streaming tool output becomes a requirement.
+ */ exports.McpController = McpController_1 = /*#__PURE__*/ function() {
+    function McpController(factory) {
+        _class_call_check$1(this, McpController);
+        _define_property$1(this, "factory", void 0);
+        _define_property$1(this, "_logger", new common.Logger(McpController_1.name));
+        this.factory = factory;
+    }
+    _create_class$1(McpController, [
+        {
+            key: "handleMcpRequest",
+            value: function handleMcpRequest(req, res) {
+                return _async_to_generator(function() {
+                    var auth, server, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                auth = req.auth;
+                                server = this.factory.createServer({
+                                    auth: auth,
+                                    rawRequest: req
+                                });
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    handleStreamableHttpMcpRequest(req, res, server)
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                this._logger.error('MCP request handling failed', error);
+                                if (!res.headersSent) {
+                                    res.status(500).json({
+                                        statusCode: 500,
+                                        message: 'MCP request handling failed'
+                                    });
+                                }
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return McpController;
+}();
+__decorate([
+    common.Post(),
+    __param(0, common.Req()),
+    __param(1, common.Res())
+], exports.McpController.prototype, "handleMcpRequest", null);
+exports.McpController = McpController_1 = __decorate([
+    common.Controller('mcp'),
+    __param(0, common.Inject(exports.McpServerFactoryService))
+], exports.McpController);
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Serves the `GET /.well-known/oauth-protected-resource` metadata document so
+ * Claude (and other MCP clients) can discover which OIDC issuer guards this
+ * MCP endpoint.
+ *
+ * The route is registered without a controller-level prefix because well-known
+ * URIs must live at the host root. Apps need to exclude `.well-known/{*path}`
+ * from any global API route prefix (see `FIREBASE_SERVER_OIDC_ROUTES_FOR_GLOBAL_ROUTE_EXCLUDE`
+ * in `firebase-server/oidc` for the corresponding OIDC excludes).
+ */ exports.McpWellKnownController = /*#__PURE__*/ function() {
+    function McpWellKnownController(mcpConfig) {
+        _class_call_check(this, McpWellKnownController);
+        _define_property(this, "mcpConfig", void 0);
+        this.mcpConfig = mcpConfig;
+    }
+    _create_class(McpWellKnownController, [
+        {
+            key: "getProtectedResourceMetadata",
+            value: function getProtectedResourceMetadata() {
+                return {
+                    resource: this.mcpConfig.mcpUrl,
+                    authorization_servers: [
+                        this.mcpConfig.oidcIssuer
+                    ]
+                };
+            }
+        }
+    ]);
+    return McpWellKnownController;
+}();
+__decorate([
+    common.Get('oauth-protected-resource')
+], exports.McpWellKnownController.prototype, "getProtectedResourceMetadata", null);
+exports.McpWellKnownController = __decorate([
+    common.Controller('.well-known'),
+    __param(0, common.Inject(McpModuleConfig))
+], exports.McpWellKnownController);
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * Routes the firebase-server/mcp module owns. Apps should exclude these from
+ * any global API route prefix (`globalApiRoutePrefix.exclude`) so the canonical
+ * URLs land at `/.well-known/...` and `/mcp` rather than `/api/.well-known/...`.
+ */ var FIREBASE_SERVER_MCP_ROUTES_FOR_GLOBAL_ROUTE_EXCLUDE = [
+    '.well-known/{*path}',
+    'mcp'
+];
+/**
+ * Generates NestJS module metadata for the firebase-server/mcp module.
+ *
+ * Mirrors the convention used by {@link modelApiModuleMetadata}: the consumer provides
+ * a dependency module that exposes the required tokens, and this factory wires up the
+ * controllers + factory service.
+ *
+ * @param metadataConfig - Configuration including the dependency module.
+ * @returns NestJS module metadata exposing the MCP transport + well-known controller.
+ *
+ * @Module ({
+ *   imports: [DemoModelApiModule],
+ *   providers: [{ provide: McpModuleConfig, useValue: { oidcIssuer, mcpUrl } }],
+ *   exports: [McpModuleConfig, ModelApiCallModelDispatchService, MODEL_API_NEST_APPLICATION_CONTEXT]
+ * })
+ * export class DemoMcpDependencyModule {}
+ * @Module (mcpModuleMetadata({ dependencyModule: DemoMcpDependencyModule }))
+ * export class DemoMcpModule {}
+ * ```
+ *
+ * @example
+ * ```typescript
+ */ function mcpModuleMetadata(metadataConfig) {
+    var dependencyModule = metadataConfig.dependencyModule, imports = metadataConfig.imports, exports$1 = metadataConfig.exports, providers = metadataConfig.providers;
+    return {
+        imports: [
+            dependencyModule
+        ].concat(_to_consumable_array(imports !== null && imports !== void 0 ? imports : [])),
+        controllers: [
+            exports.McpController,
+            exports.McpWellKnownController
+        ],
+        exports: [
+            exports.McpServerFactoryService
+        ].concat(_to_consumable_array(exports$1 !== null && exports$1 !== void 0 ? exports$1 : [])),
+        providers: [
+            exports.McpServerFactoryService
+        ].concat(_to_consumable_array(providers !== null && providers !== void 0 ? providers : []))
+    };
+}
+
+exports.DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS = DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS;
+exports.DEFAULT_MCP_PATH = DEFAULT_MCP_PATH;
+exports.DEFAULT_MCP_SERVER_NAME = DEFAULT_MCP_SERVER_NAME;
+exports.DEFAULT_SPECIFIER_KEY = DEFAULT_SPECIFIER_KEY;
+exports.DEFAULT_VOID_MCP_SUCCESS_VALUE = DEFAULT_VOID_MCP_SUCCESS_VALUE;
+exports.FIREBASE_SERVER_MCP_ROUTES_FOR_GLOBAL_ROUTE_EXCLUDE = FIREBASE_SERVER_MCP_ROUTES_FOR_GLOBAL_ROUTE_EXCLUDE;
+exports.MCP_AUTH_ROLE_READER = MCP_AUTH_ROLE_READER;
+exports.MCP_MANIFEST_VERSION = MCP_MANIFEST_VERSION;
+exports.MCP_MODEL_GET_BATCH_SIZE = MCP_MODEL_GET_BATCH_SIZE;
+exports.MODEL_DECODE_DISPATCH_CALL = MODEL_DECODE_DISPATCH_CALL;
+exports.MODEL_DECODE_DISPATCH_MODEL_TYPE = MODEL_DECODE_DISPATCH_MODEL_TYPE;
+exports.MODEL_DECODE_TOOL_NAME = MODEL_DECODE_TOOL_NAME;
+exports.MODEL_GET_DISPATCH_CALL = MODEL_GET_DISPATCH_CALL;
+exports.MODEL_GET_DISPATCH_MODEL_TYPE = MODEL_GET_DISPATCH_MODEL_TYPE;
+exports.MODEL_GET_TOOL_NAME = MODEL_GET_TOOL_NAME;
+exports.MODEL_INFO_DISPATCH_CALL = MODEL_INFO_DISPATCH_CALL;
+exports.MODEL_INFO_DISPATCH_MODEL_TYPE = MODEL_INFO_DISPATCH_MODEL_TYPE;
+exports.MODEL_INFO_TOOL_NAME = MODEL_INFO_TOOL_NAME;
+exports.McpModuleConfig = McpModuleConfig;
+exports.buildDefaultMcpToolDescription = buildDefaultMcpToolDescription;
+exports.buildMcpToolName = buildMcpToolName;
+exports.buildStaticWireEntry = buildStaticWireEntry;
+exports.classifyVisibility = classifyVisibility;
+exports.createModelDecodeTool = createModelDecodeTool;
+exports.createModelGetTool = createModelGetTool;
+exports.createModelInfoTool = createModelInfoTool;
+exports.decodeFirestoreModelKey = decodeFirestoreModelKey;
+exports.findModelEntry = findModelEntry;
+exports.formatMcpToolErrorResponse = formatMcpToolErrorResponse;
+exports.formatMcpToolResponse = formatMcpToolResponse;
+exports.generateMcpToolDefinitions = generateMcpToolDefinitions;
+exports.handleStreamableHttpMcpRequest = handleStreamableHttpMcpRequest;
+exports.mcpManifestKey = mcpManifestKey;
+exports.mcpModuleMetadata = mcpModuleMetadata;
+exports.resolveEffectiveReadOnly = resolveEffectiveReadOnly;
+exports.resolveRequiredScope = resolveRequiredScope;