@dereekb/firebase-server 13.37.0 → 13.38.0

package/mcp/index.cjs.js

@@ -16,7 +16,7 @@ function _class_call_check$5(instance, Constructor) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _define_property$9(obj, key, value) {
+function _define_property$a(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -87,7 +87,7 @@ function _define_property$9(obj, key, value) {
      * discovery document. Claude custom-connector reads this to discover the OIDC issuer.
      *
      * @example 'https://api.example.com/oidc'
-     */ _define_property$9(this, "oidcIssuer", void 0);
+     */ _define_property$a(this, "oidcIssuer", void 0);
     /**
      * The canonical resource URL of the MCP endpoint.
      *
@@ -95,7 +95,7 @@ function _define_property$9(obj, key, value) {
      * and used as the audience the access token's `aud` claim should match.
      *
      * @example 'https://api.example.com/mcp'
-     */ _define_property$9(this, "mcpUrl", void 0);
+     */ _define_property$a(this, "mcpUrl", void 0);
     /**
      * Optional filter applied to the OIDC provider's scope list when building the
      * protected-resource discovery document's `scopes_supported` (RFC 9728 §2).
@@ -114,19 +114,19 @@ function _define_property$9(obj, key, value) {
      * the OIDC provider nothing to grant and ending the interaction in `access_denied`.
      *
      * @example (allScopes) => allScopes.filter((scope) => scope === 'openid' || scope.startsWith('model.'))
-     */ _define_property$9(this, "scopesSupported", void 0);
+     */ _define_property$a(this, "scopesSupported", void 0);
     /**
      * Optional name advertised on the MCP `initialize` handshake. Defaults to
      * {@link DEFAULT_MCP_SERVER_NAME}.
-     */ _define_property$9(this, "serverName", void 0);
+     */ _define_property$a(this, "serverName", void 0);
     /**
      * Optional version advertised on the MCP `initialize` handshake.
-     */ _define_property$9(this, "serverVersion", void 0);
+     */ _define_property$a(this, "serverVersion", void 0);
     /**
      * Optional override for the `instructions` string passed to `new McpServer(...)` and
      * advertised on the JSON-RPC `initialize` handshake. Defaults to
      * {@link DEFAULT_MCP_SERVER_INSTRUCTIONS}.
-     */ _define_property$9(this, "serverInstructions", void 0);
+     */ _define_property$a(this, "serverInstructions", 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
@@ -136,7 +136,7 @@ function _define_property$9(obj, key, value) {
      * 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$9(this, "mcpManifestPath", void 0);
+     */ _define_property$a(this, "mcpManifestPath", void 0);
     /**
      * Absolute path to a pre-rendered route manifest JSON file produced by
      * `dbx-cli-generate-route-manifest`. When set, the runtime reads it once at
@@ -146,7 +146,7 @@ function _define_property$9(obj, key, value) {
      * Optional. When unset or the file is missing, the runtime skips registering
      * `url-models` and emits a single boot warning when the path was set but
      * unreadable.
-     */ _define_property$9(this, "mcpRouteManifestPath", void 0);
+     */ _define_property$a(this, "mcpRouteManifestPath", void 0);
     /**
      * When `true`, the MCP server only advertises tools whose effective read-only classification is `true`.
      *
@@ -156,7 +156,7 @@ function _define_property$9(obj, key, value) {
      *
      * The advertised `serverName` on the JSON-RPC `initialize` handshake is suffixed with
      * ` (read-only)` so the client surface reflects the mode.
-     */ _define_property$9(this, "readOnly", void 0);
+     */ _define_property$a(this, "readOnly", void 0);
     /**
      * Controls the auto-injected `reason` parameter added to every advertised tool's input schema.
      *
@@ -166,7 +166,7 @@ function _define_property$9(obj, key, value) {
      * When enabled, every advertised tool's `inputSchema` carries a required `reason` string the model
      * fills with a short justification for the call. The value is forwarded to analytics and stripped
      * from the dispatched handler body. See {@link McpReasonParameterConfig}.
-     */ _define_property$9(this, "reasonParameter", void 0);
+     */ _define_property$a(this, "reasonParameter", void 0);
     /**
      * Default OIDC scope group term required on EVERY `callModel` op, mirrored into MCP tool-list
      * visibility, unless a finer term overrides it (a per-function `requiredScope`, then a
@@ -176,17 +176,20 @@ function _define_property$9(obj, key, value) {
      *
      * Set this to the SAME value passed to `ModelApiDispatchConfig.defaultRequiredScope` to
      * keep tool visibility and enforcement in lockstep.
-     */ _define_property$9(this, "defaultRequiredScope", void 0);
+     */ _define_property$a(this, "defaultRequiredScope", void 0);
     /**
      * Per-model OIDC scope group-term overrides, keyed by {@link FirestoreModelType}, mirrored into MCP
      * tool-list visibility. Set this to the SAME value passed to
      * `ModelApiDispatchConfig.modelRequiredScopes` so per-model / verb-keyed restrictions that
      * confine a subset client apply identically to the advertised tool list.
-     */ _define_property$9(this, "modelRequiredScopes", void 0);
+     */ _define_property$a(this, "modelRequiredScopes", void 0);
 };
 /**
  * NestJS injection token for the optional {@link McpAuthRoleReader} provider.
  */ var MCP_AUTH_ROLE_READER = 'MCP_AUTH_ROLE_READER';
+/**
+ * NestJS injection token for the optional {@link McpModelRolesTargetUidPredicate} provider.
+ */ var MCP_MODEL_ROLES_TARGET_UID_PREDICATE = 'MCP_MODEL_ROLES_TARGET_UID_PREDICATE';
 
 function _type_of$5(obj) {
     "@swc/helpers - typeof";
@@ -216,7 +219,7 @@ function _array_like_to_array$b(arr, len) {
 function _array_without_holes$8(arr) {
     if (Array.isArray(arr)) return _array_like_to_array$b(arr);
 }
-function _define_property$8(obj, key, value) {
+function _define_property$9(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -235,7 +238,7 @@ function _iterable_to_array$8(iter) {
 function _non_iterable_spread$8() {
     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$6(target) {
+function _object_spread$7(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -245,7 +248,7 @@ function _object_spread$6(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$8(target, key, source[key]);
+            _define_property$9(target, key, source[key]);
         });
     }
     return target;
@@ -355,9 +358,9 @@ function _unsupported_iterable_to_array$b(o, minLen) {
         var _base_type;
         var base = (typeof inputSchema === "undefined" ? "undefined" : _type_of$4(inputSchema)) === 'object' && inputSchema != null ? inputSchema : {};
         var existingProperties = _type_of$4(base.properties) === 'object' && base.properties != null ? base.properties : {};
-        var next = _object_spread_props$3(_object_spread$6({}, base), {
+        var next = _object_spread_props$3(_object_spread$7({}, base), {
             type: (_base_type = base.type) !== null && _base_type !== void 0 ? _base_type : 'object',
-            properties: _object_spread_props$3(_object_spread$6({}, existingProperties), _define_property$8({}, resolved.parameterName, {
+            properties: _object_spread_props$3(_object_spread$7({}, existingProperties), _define_property$9({}, resolved.parameterName, {
                 type: 'string',
                 maxLength: resolved.maxLength,
                 description: resolved.description
@@ -391,7 +394,7 @@ function _unsupported_iterable_to_array$b(o, minLen) {
     var result;
     if (resolved.enabled && !toolDeclaresOwnReason && Object.prototype.hasOwnProperty.call(args, resolved.parameterName)) {
         var rawValue = args[resolved.parameterName];
-        var nextArgs = _object_spread$6({}, args);
+        var nextArgs = _object_spread$7({}, args);
         delete nextArgs[resolved.parameterName];
         var stringValue = rawValue == null ? '' : String(rawValue);
         var clamped = stringValue.length > resolved.maxLength ? stringValue.slice(0, resolved.maxLength) : stringValue;
@@ -746,7 +749,7 @@ function scoreCandidates(states, pathname) {
     });
 }
 
-function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -760,16 +763,16 @@ function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$6(fn) {
+function _async_to_generator$7(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -783,7 +786,7 @@ function _instanceof$1(left, right) {
         return left instanceof right;
     }
 }
-function _ts_generator$6(thisArg, body) {
+function _ts_generator$7(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -911,9 +914,9 @@ function _ts_generator$6(thisArg, body) {
  * @param details - The handler-level API details (carries the mapper + Tier 2/3 formatters).
  * @returns The MCP tool response content.
  */ function formatMcpToolResponse(result, params, details) {
-    return _async_to_generator$6(function() {
+    return _async_to_generator$7(function() {
         var mcp, value, _tmp, context, response, summary;
-        return _ts_generator$6(this, function(_state) {
+        return _ts_generator$7(this, function(_state) {
             switch(_state.label){
                 case 0:
                     mcp = details === null || details === void 0 ? void 0 : details.mcp;
@@ -1773,7 +1776,7 @@ function _array_like_to_array$8(arr, len) {
 function _array_without_holes$7(arr) {
     if (Array.isArray(arr)) return _array_like_to_array$8(arr);
 }
-function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -1787,16 +1790,16 @@ function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$5(fn) {
+function _async_to_generator$6(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -1819,7 +1822,7 @@ function _unsupported_iterable_to_array$8(o, minLen) {
     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$8(o, minLen);
 }
-function _ts_generator$5(thisArg, body) {
+function _ts_generator$6(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -1980,9 +1983,9 @@ function _ts_generator$5(thisArg, body) {
 }
 // MARK: Handler
 function modelGetToolHandler(args, ctx, deps) {
-    return _async_to_generator$5(function() {
+    return _async_to_generator$6(function() {
         var result, input, identity, resolvedKeys, merged, error;
-        return _ts_generator$5(this, function(_state) {
+        return _ts_generator$6(this, function(_state) {
             switch(_state.label){
                 case 0:
                     _state.trys.push([
@@ -1996,7 +1999,7 @@ function modelGetToolHandler(args, ctx, deps) {
                     if (identity == null) {
                         throw new Error("Unknown modelType: ".concat(input.modelType));
                     }
-                    resolvedKeys = resolveKeys(input.keys, identity);
+                    resolvedKeys = resolveKeys$1(input.keys, identity);
                     return [
                         4,
                         readInChunks$1({
@@ -2057,7 +2060,7 @@ function parseModelGetInput(args) {
         keys: normalizedKeys
     };
 }
-function resolveKeys(keys, identity) {
+function resolveKeys$1(keys, identity) {
     var isRoot = identity.type === 'root';
     var resolved = [];
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
@@ -2089,9 +2092,9 @@ function resolveKeys(keys, identity) {
     return resolved;
 }
 function readInChunks$1(input) {
-    return _async_to_generator$5(function() {
+    return _async_to_generator$6(function() {
         var modelType, keys, auth, readDocuments, merged, offset, _merged_results, _merged_errors, batch, partial;
-        return _ts_generator$5(this, function(_state) {
+        return _ts_generator$6(this, function(_state) {
             switch(_state.label){
                 case 0:
                     modelType = input.modelType, keys = input.keys, auth = input.auth, readDocuments = input.readDocuments;
@@ -2205,6 +2208,512 @@ var MODEL_GET_OUTPUT_SCHEMA = {
     }
 };
 
+function asyncGeneratorStep$5(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$5(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$8(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$6(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$8(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator$5(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-roles` static tool.
+ */ var MODEL_ROLES_TOOL_NAME = 'model-roles';
+/**
+ * Synthetic call type used in the tool's dispatch identity. Distinct from `model-get`'s `get` so
+ * visibility predicates can target the two independently.
+ */ var MODEL_ROLES_DISPATCH_CALL = 'roles';
+/**
+ * Synthetic model type used in the tool's dispatch identity. Mirrors {@link MODEL_GET_DISPATCH_MODEL_TYPE}
+ * — the tool isn't bound to one model type, so the literal "model" stands in.
+ */ var MODEL_ROLES_DISPATCH_MODEL_TYPE = 'model';
+/**
+ * Maximum number of keys accepted per `model-roles` call. Role resolution runs the model's real
+ * permission delegate per key (which may itself read parent documents), so this is deliberately
+ * lower than the `model-get` batch size.
+ */ var MCP_MODEL_ROLES_MAX_KEYS = 25;
+// MARK: Factory
+/**
+ * Builds the built-in `model-roles` MCP tool definition.
+ *
+ * Answers "what is this user actually allowed to do with this document?" by running the same
+ * `roleMapForModel()` delegate the permission-checked read/write paths use, and returning the
+ * resolved roles instead of consuming them. Because the model's real delegate runs, derived and
+ * cascading roles appear exactly as the API grants them — there is no second implementation of the
+ * rules to drift.
+ *
+ * Two things it disambiguates that a plain read cannot:
+ * - **Missing vs. forbidden.** A key that resolves to a missing document returns
+ *   `exists: false, roles: []` rather than an error, so "the document is not there" reads
+ *   differently from "it is there and you have no access" (`exists: true, roles: []`).
+ * - **Full access.** Admin short-circuits that grant the full-access marker come back as
+ *   `fullAccess: true` rather than as an opaque enumerated set.
+ *
+ * By default roles are resolved for the calling user. Passing `uid` resolves them for another user
+ * and is gated behind {@link CreateModelRolesToolDeps.canTargetOtherUids}.
+ *
+ * @param deps - Role-map reader, identity resolver, and the target-uid authorization predicate.
+ * @returns A statically-registered {@link McpToolDefinition} ready to be appended to the MCP
+ *   server factory's tool registry.
+ */ function createModelRolesTool(deps) {
+    var handler = function handler(args, ctx) {
+        return modelRolesToolHandler(args, ctx, deps);
+    };
+    var name = MODEL_ROLES_TOOL_NAME;
+    var description = 'Resolve which roles the current user (or, with "uid", another user) is granted on one or more model keys — the same permission computation the API runs, returned instead of enforced. Use to answer "why was this forbidden?" and to tell a missing document (exists:false) apart from one you cannot access (exists:true, roles:[]). Admin full-access short-circuits report fullAccess:true. Targeting another uid requires elevated access.';
+    return buildStaticToolDefinition({
+        name: name,
+        description: description,
+        inputSchema: MODEL_ROLES_INPUT_SCHEMA,
+        outputSchema: MODEL_ROLES_OUTPUT_SCHEMA,
+        dispatch: {
+            call: MODEL_ROLES_DISPATCH_CALL,
+            modelType: MODEL_ROLES_DISPATCH_MODEL_TYPE
+        },
+        staticHandler: handler,
+        effectiveReadOnly: true,
+        rule: {
+            requireAuthenticated: true
+        }
+    });
+}
+// MARK: Handler
+function modelRolesToolHandler(args, ctx, deps) {
+    return _async_to_generator$5(function() {
+        var result, input, identity, targetUid, keys, resolved, error;
+        return _ts_generator$5(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        3,
+                        ,
+                        4
+                    ]);
+                    input = parseModelRolesInput(args);
+                    identity = deps.resolveIdentity(input.modelType, ctx.auth);
+                    if (identity == null) {
+                        throw new Error("Unknown modelType: ".concat(input.modelType));
+                    }
+                    return [
+                        4,
+                        resolveTargetUid({
+                            requestedUid: input.uid,
+                            auth: ctx.auth,
+                            canTargetOtherUids: deps.canTargetOtherUids
+                        })
+                    ];
+                case 1:
+                    targetUid = _state.sent();
+                    keys = resolveKeys(input.keys, identity);
+                    return [
+                        4,
+                        deps.readRoleMaps(_object_spread$6({
+                            modelType: input.modelType,
+                            keys: keys,
+                            auth: ctx.auth
+                        }, targetUid == null ? {} : {
+                            targetUid: targetUid
+                        }))
+                    ];
+                case 2:
+                    resolved = _state.sent();
+                    result = {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(resolved)
+                            }
+                        ],
+                        structuredContent: resolved
+                    };
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    error = _state.sent();
+                    result = formatMcpToolErrorResponse(error);
+                    return [
+                        3,
+                        4
+                    ];
+                case 4:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Resolves the effective target uid for a call, enforcing the elevated-access gate.
+ *
+ * Requesting your own uid is always allowed and is treated as no target at all, so a caller that
+ * passes their own uid never trips the predicate.
+ *
+ * @param input - The requested uid, the caller's auth, and the authorization predicate.
+ * @returns The uid to resolve as, or `undefined` to resolve as the caller.
+ * @throws {Error} When another user's uid is requested and the predicate denies (or is absent).
+ */ function resolveTargetUid(input) {
+    return _async_to_generator$5(function() {
+        var requestedUid, auth, canTargetOtherUids, result, allowed, _tmp;
+        return _ts_generator$5(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    requestedUid = input.requestedUid, auth = input.auth, canTargetOtherUids = input.canTargetOtherUids;
+                    if (!(requestedUid != null && requestedUid !== (auth === null || auth === void 0 ? void 0 : auth.uid))) return [
+                        3,
+                        4
+                    ];
+                    if (!(canTargetOtherUids == null)) return [
+                        3,
+                        1
+                    ];
+                    _tmp = false;
+                    return [
+                        3,
+                        3
+                    ];
+                case 1:
+                    return [
+                        4,
+                        canTargetOtherUids(auth)
+                    ];
+                case 2:
+                    _tmp = _state.sent();
+                    _state.label = 3;
+                case 3:
+                    allowed = _tmp;
+                    if (!allowed) {
+                        throw new Error("model-roles: resolving roles for another user's uid requires elevated access.");
+                    }
+                    result = requestedUid;
+                    _state.label = 4;
+                case 4:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+function parseModelRolesInput(args) {
+    var modelType = args['modelType'];
+    var keys = args['keys'];
+    var uid = args['uid'];
+    if (typeof modelType !== 'string' || modelType.length === 0) {
+        throw new Error('model-roles: "modelType" is required and must be a non-empty string.');
+    }
+    if (!Array.isArray(keys) || keys.length === 0) {
+        throw new Error('model-roles: "keys" is required and must be a non-empty array.');
+    }
+    if (keys.length > MCP_MODEL_ROLES_MAX_KEYS) {
+        throw new Error("model-roles: at most ".concat(MCP_MODEL_ROLES_MAX_KEYS, " keys may be resolved per call (received ").concat(keys.length, ")."));
+    }
+    if (uid !== undefined && (typeof uid !== 'string' || uid.length === 0)) {
+        throw new Error('model-roles: "uid" must be a non-empty string when provided.');
+    }
+    var normalizedKeys = keys.map(function(value, index) {
+        if (typeof value !== 'string' || value.length === 0) {
+            throw new Error("model-roles: keys[".concat(index, "] must be a non-empty string."));
+        }
+        return value;
+    });
+    return _object_spread$6({
+        modelType: modelType,
+        keys: normalizedKeys
+    }, uid === undefined ? {} : {
+        uid: uid
+    });
+}
+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-roles: 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;
+}
+// MARK: Schemas
+var MODEL_ROLES_INPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'modelType',
+        'keys'
+    ],
+    properties: {
+        modelType: {
+            type: 'string',
+            minLength: 1,
+            description: 'Firestore model type to resolve roles on (e.g. "guestbook", "profile").'
+        },
+        keys: {
+            type: 'array',
+            minItems: 1,
+            maxItems: MCP_MODEL_ROLES_MAX_KEYS,
+            description: 'Full keys ("prefix/id") or bare ids (root models only).',
+            items: {
+                type: 'string',
+                minLength: 1
+            }
+        },
+        uid: {
+            type: 'string',
+            minLength: 1,
+            description: 'Resolve roles as this user instead of the caller. Requires elevated access; passing your own uid is always allowed.'
+        }
+    },
+    additionalProperties: false
+};
+var MODEL_ROLES_OUTPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'targeted',
+        'results',
+        'errors'
+    ],
+    properties: {
+        uid: {
+            type: 'string',
+            description: 'The uid the roles were resolved for.'
+        },
+        targeted: {
+            type: 'boolean',
+            description: 'True when the roles were resolved for a user other than the caller.'
+        },
+        results: {
+            type: 'array',
+            description: 'Per-key resolved permission state.',
+            items: {
+                type: 'object',
+                required: [
+                    'key',
+                    'exists',
+                    'fullAccess',
+                    'roles'
+                ],
+                properties: {
+                    key: {
+                        type: 'string'
+                    },
+                    exists: {
+                        type: 'boolean',
+                        description: 'Whether the document exists. Roles are only computed for documents that exist.'
+                    },
+                    fullAccess: {
+                        type: 'boolean',
+                        description: 'True when the full-access marker was granted; every role is implicitly held and "roles" is empty.'
+                    },
+                    roles: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Granted role names, sorted.'
+                    }
+                }
+            }
+        },
+        errors: {
+            type: 'array',
+            description: 'Per-key failures. A missing document is NOT an error — it appears in results with exists:false.',
+            items: {
+                type: 'object',
+                required: [
+                    'key',
+                    'message'
+                ],
+                properties: {
+                    key: {
+                        type: 'string'
+                    },
+                    message: {
+                        type: 'string'
+                    },
+                    code: {
+                        type: 'string'
+                    }
+                }
+            }
+        }
+    }
+};
+
 function _array_like_to_array$7(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];
@@ -6060,13 +6569,14 @@ var McpServerFactoryService_1;
  * per request and has no session concept at all — and it is equally what the SDK
  * recommends for stateless 2025-era serving, so one factory backs both eras.
  */ exports.McpServerFactoryService = McpServerFactoryService_1 = /*#__PURE__*/ function() {
-    function McpServerFactoryService(mcpConfig, dispatchService, modelApiGetService, roleReader, analyticsService, storageService) {
+    function McpServerFactoryService(mcpConfig, dispatchService, modelApiGetService, roleReader, analyticsService, storageService, modelRolesTargetUidPredicate) {
         _class_call_check$3(this, McpServerFactoryService);
         _define_property$3(this, "mcpConfig", void 0);
         _define_property$3(this, "dispatchService", void 0);
         _define_property$3(this, "modelApiGetService", void 0);
         _define_property$3(this, "roleReader", void 0);
         _define_property$3(this, "storageService", void 0);
+        _define_property$3(this, "modelRolesTargetUidPredicate", void 0);
         _define_property$3(this, "_logger", new common.Logger(McpServerFactoryService_1.name));
         _define_property$3(this, "_cachedTools", void 0);
         _define_property$3(this, "_cachedStaticTools", void 0);
@@ -6086,6 +6596,7 @@ var McpServerFactoryService_1;
         this.modelApiGetService = modelApiGetService;
         this.roleReader = roleReader;
         this.storageService = storageService;
+        this.modelRolesTargetUidPredicate = modelRolesTargetUidPredicate;
         this._analyticsService = analyticsService !== null && analyticsService !== void 0 ? analyticsService : noopMcpAnalyticsService();
     }
     _create_class$3(McpServerFactoryService, [
@@ -6356,6 +6867,14 @@ var McpServerFactoryService_1;
                             resolveIdentity: function resolveIdentity(modelType, auth) {
                                 return getService.getModelIdentity(modelType, auth);
                             }
+                        }), createModelRolesTool({
+                            readRoleMaps: function readRoleMaps(params) {
+                                return getService.readRoleMaps(params);
+                            },
+                            resolveIdentity: function resolveIdentity(modelType, auth) {
+                                return getService.getModelIdentity(modelType, auth);
+                            },
+                            canTargetOtherUids: this.modelRolesTargetUidPredicate
                         }));
                         // `url-models` reuses the model-get read/identity path, so it is only offered when the get
                         // service is wired AND a route manifest with at least one state was loaded.
@@ -7109,7 +7628,9 @@ exports.McpServerFactoryService = McpServerFactoryService_1 = __decorate([
     __param(4, common.Optional()),
     __param(4, common.Inject(MCP_ANALYTICS_SERVICE)),
     __param(5, common.Optional()),
-    __param(5, common.Inject(firebaseServer.FirebaseServerStorageService))
+    __param(5, common.Inject(firebaseServer.FirebaseServerStorageService)),
+    __param(6, common.Optional()),
+    __param(6, common.Inject(MCP_MODEL_ROLES_TARGET_UID_PREDICATE))
 ], exports.McpServerFactoryService);
 
 function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
@@ -8195,6 +8716,8 @@ exports.MCP_AUTH_ROLE_READER = MCP_AUTH_ROLE_READER;
 exports.MCP_CALL_TYPE_ABBREVIATIONS = MCP_CALL_TYPE_ABBREVIATIONS;
 exports.MCP_MANIFEST_VERSION = MCP_MANIFEST_VERSION;
 exports.MCP_MODEL_GET_BATCH_SIZE = MCP_MODEL_GET_BATCH_SIZE;
+exports.MCP_MODEL_ROLES_MAX_KEYS = MCP_MODEL_ROLES_MAX_KEYS;
+exports.MCP_MODEL_ROLES_TARGET_UID_PREDICATE = MCP_MODEL_ROLES_TARGET_UID_PREDICATE;
 exports.MCP_TOOL_NAME_MAX_LENGTH = MCP_TOOL_NAME_MAX_LENGTH;
 exports.MCP_TOOL_NAME_WARN_LENGTH = MCP_TOOL_NAME_WARN_LENGTH;
 exports.MCP_WRITE_TOOL_DESCRIPTION_PREFIX = MCP_WRITE_TOOL_DESCRIPTION_PREFIX;
@@ -8209,6 +8732,9 @@ exports.MODEL_INFO_DISPATCH_MODEL_TYPE = MODEL_INFO_DISPATCH_MODEL_TYPE;
 exports.MODEL_INFO_GROUPS_HINT = MODEL_INFO_GROUPS_HINT;
 exports.MODEL_INFO_TOOL_NAME = MODEL_INFO_TOOL_NAME;
 exports.MODEL_INFO_UNGROUPED_LABEL = MODEL_INFO_UNGROUPED_LABEL;
+exports.MODEL_ROLES_DISPATCH_CALL = MODEL_ROLES_DISPATCH_CALL;
+exports.MODEL_ROLES_DISPATCH_MODEL_TYPE = MODEL_ROLES_DISPATCH_MODEL_TYPE;
+exports.MODEL_ROLES_TOOL_NAME = MODEL_ROLES_TOOL_NAME;
 exports.McpAnalyticsService = McpAnalyticsService;
 exports.McpModuleConfig = McpModuleConfig;
 exports.ROUTE_MANIFEST_VERSION = ROUTE_MANIFEST_VERSION;
@@ -8231,6 +8757,7 @@ exports.createEnumInfoTool = createEnumInfoTool;
 exports.createModelDecodeTool = createModelDecodeTool;
 exports.createModelGetTool = createModelGetTool;
 exports.createModelInfoTool = createModelInfoTool;
+exports.createModelRolesTool = createModelRolesTool;
 exports.createUrlModelsTool = createUrlModelsTool;
 exports.decodeFirestoreModelKey = decodeFirestoreModelKey;
 exports.extractMcpReasonFromArgs = extractMcpReasonFromArgs;