@dereekb/firebase-server 13.14.0 → 13.15.0

package/mcp/index.cjs.js

@@ -117,13 +117,13 @@ function _define_property$7(obj, key, value) {
  * NestJS injection token for the optional {@link McpAuthRoleReader} provider.
  */ var MCP_AUTH_ROLE_READER = 'MCP_AUTH_ROLE_READER';
 
-function _type_of$2(obj) {
+function _type_of$3(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$2(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    if ((typeof Reflect === "undefined" ? "undefined" : _type_of$3(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;
 }
@@ -192,7 +192,7 @@ function _class_call_check$4(instance, Constructor) {
     return isDefault ? "".concat(modelType, ".").concat(call, "._") : "".concat(modelType, ".").concat(call, ".").concat(specifier);
 }
 
-function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -206,22 +206,22 @@ function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$4(fn) {
+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$4(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _instanceof(left, right) {
+function _instanceof$1(left, right) {
     "@swc/helpers - instanceof";
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -229,7 +229,7 @@ function _instanceof(left, right) {
         return left instanceof right;
     }
 }
-function _ts_generator$4(thisArg, body) {
+function _ts_generator$5(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -357,9 +357,9 @@ function _ts_generator$4(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$4(function() {
+    return _async_to_generator$5(function() {
         var mcp, value, _tmp, context, response, summary;
-        return _ts_generator$4(this, function(_state) {
+        return _ts_generator$5(this, function(_state) {
             switch(_state.label){
                 case 0:
                     mcp = details === null || details === void 0 ? void 0 : details.mcp;
@@ -425,7 +425,7 @@ function _ts_generator$4(thisArg, body) {
  * @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);
+    var message = _instanceof$1(error, Error) ? error.message : String(error);
     return {
         isError: true,
         content: [
@@ -523,15 +523,15 @@ function stringifyResult(result) {
     return firebase.callModelOidcScopeForCallType(callType);
 }
 
-function _array_like_to_array$6(arr, len) {
+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];
     return arr2;
 }
-function _array_with_holes$2(arr) {
+function _array_with_holes$3(arr) {
     if (Array.isArray(arr)) return arr;
 }
-function _iterable_to_array_limit$2(arr, i) {
+function _iterable_to_array_limit$3(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
     var _arr = [];
@@ -555,23 +555,23 @@ function _iterable_to_array_limit$2(arr, i) {
     }
     return _arr;
 }
-function _non_iterable_rest$2() {
+function _non_iterable_rest$3() {
     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$6(arr, i) || _non_iterable_rest$2();
+function _sliced_to_array$3(arr, i) {
+    return _array_with_holes$3(arr) || _iterable_to_array_limit$3(arr, i) || _unsupported_iterable_to_array$7(arr, i) || _non_iterable_rest$3();
 }
-function _type_of$1(obj) {
+function _type_of$2(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$6(o, minLen) {
+function _unsupported_iterable_to_array$7(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$6(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$7(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$6(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$7(o, minLen);
 }
 /**
  * Default `toJsonSchema()` options.
@@ -837,18 +837,18 @@ function _unsupported_iterable_to_array$6(o, minLen) {
     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 _step_value = _sliced_to_array$3(_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];
+                    var _step_value1 = _sliced_to_array$3(_step1.value, 2), callType = _step_value1[0], callDetails = _step_value1[1];
                     if (callDetails == null) {
                         continue;
                     }
                     var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
                     try {
                         for(var _iterator2 = Object.entries(callDetails.specifiers)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
-                            var _step_value2 = _sliced_to_array$2(_step2.value, 2), specifierKey = _step_value2[0], handlerDetails = _step_value2[1];
+                            var _step_value2 = _sliced_to_array$3(_step2.value, 2), specifierKey = _step_value2[0], handlerDetails = _step_value2[1];
                             var _ref;
                             var _naming_modelSegments, _handlerDetails_mcp, _handlerDetails_mcp1;
                             if (handlerDetails == null) {
@@ -1096,7 +1096,7 @@ function resolveInputSchema(context) {
     var result;
     try {
         var exported = model.arktypeToJsonSchemaForExport(handlerDetails.inputType);
-        if (exported && (typeof exported === "undefined" ? "undefined" : _type_of$1(exported)) === 'object') {
+        if (exported && (typeof exported === "undefined" ? "undefined" : _type_of$2(exported)) === 'object') {
             result = exported;
         } else {
             // arktypeToJsonSchemaForExport returned a non-object (shouldn't happen for object schemas).
@@ -1115,15 +1115,15 @@ function resolveInputSchema(context) {
     return result;
 }
 
-function _array_like_to_array$5(arr, len) {
+function _array_like_to_array$6(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$5(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$5(arr);
+    if (Array.isArray(arr)) return _array_like_to_array$6(arr);
 }
-function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -1137,16 +1137,16 @@ function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$3(fn) {
+function _async_to_generator$4(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);
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -1159,17 +1159,17 @@ function _non_iterable_spread$5() {
     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$5(arr) {
-    return _array_without_holes$5(arr) || _iterable_to_array$5(arr) || _unsupported_iterable_to_array$5(arr) || _non_iterable_spread$5();
+    return _array_without_holes$5(arr) || _iterable_to_array$5(arr) || _unsupported_iterable_to_array$6(arr) || _non_iterable_spread$5();
 }
-function _unsupported_iterable_to_array$5(o, minLen) {
+function _unsupported_iterable_to_array$6(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$5(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$6(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$5(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$6(o, minLen);
 }
-function _ts_generator$3(thisArg, body) {
+function _ts_generator$4(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -1339,9 +1339,9 @@ function _ts_generator$3(thisArg, body) {
 }
 // MARK: Handler
 function modelGetToolHandler(args, ctx, deps) {
-    return _async_to_generator$3(function() {
+    return _async_to_generator$4(function() {
         var result, input, identity, resolvedKeys, merged, error;
-        return _ts_generator$3(this, function(_state) {
+        return _ts_generator$4(this, function(_state) {
             switch(_state.label){
                 case 0:
                     _state.trys.push([
@@ -1448,9 +1448,9 @@ function resolveKeys(keys, identity) {
     return resolved;
 }
 function readInChunks(input) {
-    return _async_to_generator$3(function() {
+    return _async_to_generator$4(function() {
         var modelType, keys, auth, readDocuments, merged, offset, _merged_results, _merged_errors, batch, partial;
-        return _ts_generator$3(this, function(_state) {
+        return _ts_generator$4(this, function(_state) {
             switch(_state.label){
                 case 0:
                     modelType = input.modelType, keys = input.keys, auth = input.auth, readDocuments = input.readDocuments;
@@ -1564,13 +1564,13 @@ var MODEL_GET_OUTPUT_SCHEMA = {
     }
 };
 
-function _array_like_to_array$4(arr, len) {
+function _array_like_to_array$5(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$4(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
+    if (Array.isArray(arr)) return _array_like_to_array$5(arr);
 }
 function _define_property$6(obj, key, value) {
     if (key in obj) {
@@ -1626,15 +1626,15 @@ function _object_spread_props(target, source) {
     return target;
 }
 function _to_consumable_array$4(arr) {
-    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$4();
+    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$5(arr) || _non_iterable_spread$4();
 }
-function _unsupported_iterable_to_array$4(o, minLen) {
+function _unsupported_iterable_to_array$5(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$5(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);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$5(o, minLen);
 }
 // MARK: Constants
 /**
@@ -2539,16 +2539,16 @@ var MODEL_DECODE_OUTPUT_SCHEMA = {
     }
 };
 
-function _array_like_to_array$3(arr, len) {
+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$1(arr) {
+function _array_with_holes$2(arr) {
     if (Array.isArray(arr)) return arr;
 }
 function _array_without_holes$3(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
+    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
 }
 function _define_property$4(obj, key, value) {
     if (key in obj) {
@@ -2566,7 +2566,7 @@ function _define_property$4(obj, key, value) {
 function _iterable_to_array$3(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _iterable_to_array_limit$1(arr, i) {
+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 = [];
@@ -2590,7 +2590,7 @@ function _iterable_to_array_limit$1(arr, i) {
     }
     return _arr;
 }
-function _non_iterable_rest$1() {
+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 _non_iterable_spread$3() {
@@ -2611,19 +2611,19 @@ function _object_spread(target) {
     }
     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$3(arr, i) || _non_iterable_rest$1();
+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 _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();
+    return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$3();
 }
-function _unsupported_iterable_to_array$3(o, minLen) {
+function _unsupported_iterable_to_array$4(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    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$3(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
 }
 // MARK: Constants
 /**
@@ -2697,10 +2697,10 @@ function whoamiToolHandler(ctx, deps) {
     }
     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];
+        var _param = _sliced_to_array$2(param, 2), value = _param[1];
         return value !== undefined;
     }).map(function(param) {
-        var _param = _sliced_to_array$1(param, 1), key = _param[0];
+        var _param = _sliced_to_array$2(param, 1), key = _param[0];
         return key;
     });
     var roleSet = deps.roleReader == null ? new Set() : deps.roleReader(token);
@@ -2973,18 +2973,15 @@ var WHOAMI_OUTPUT_SCHEMA = {
     }
 };
 
-function _array_like_to_array$2(arr, len) {
+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_with_holes(arr) {
+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 asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -2998,56 +2995,30 @@ function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$2(fn) {
+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$2(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _class_call_check$3(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties$3(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$3(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
-    return Constructor;
-}
-function _define_property$3(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
     } else {
-        obj[key] = value;
+        return left instanceof right;
     }
-    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(arr, i) {
+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 = [];
@@ -3071,27 +3042,25 @@ function _iterable_to_array_limit(arr, i) {
     }
     return _arr;
 }
-function _non_iterable_rest() {
+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 _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest();
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$3(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 _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$2(o, minLen) {
+function _unsupported_iterable_to_array$3(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    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$2(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
 }
-function _ts_generator$2(thisArg, body) {
+function _ts_generator$3(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -3190,75 +3159,975 @@ function _ts_generator$2(thisArg, body) {
         };
     }
 }
-var McpServerFactoryService_1;
+// MARK: Constants
 /**
- * Injectable factory that builds {@link McpServer} instances pre-wired to the
- * call model dispatch chain.
+ * Reserved tool name for the built-in `batch-execute` static tool.
+ */ var BATCH_EXECUTE_TOOL_NAME = 'batch-execute';
+/**
+ * Synthetic call type used in the tool's dispatch identity (analytics only — the tool re-dispatches
+ * to other callModel tools rather than resolving a `batch` call type of its own).
+ */ var BATCH_EXECUTE_DISPATCH_CALL = 'batch';
+/**
+ * Synthetic model type used in the tool's dispatch identity. The tool isn't bound to a model type
+ * (each operation carries its own), so we use the literal "batch" as the identity. Apps avoiding
+ * collision should not register a real model literally named "batch".
+ */ var BATCH_EXECUTE_DISPATCH_MODEL_TYPE = 'batch';
+/**
+ * Default per-operation concurrency when the caller does not specify `maxParallel`.
+ */ var DEFAULT_BATCH_EXECUTE_MAX_PARALLEL = 5;
+/**
+ * Hard upper bound on operations accepted in a single batch file, guarding against an
+ * accidentally enormous upload exhausting the function's memory/time budget.
+ */ var MAX_BATCH_EXECUTE_OPERATIONS = 1000;
+/**
+ * Maximum bytes read from the operations file. NDJSON of typical CRUD payloads stays well under
+ * this; an oversized file is rejected rather than streamed.
+ */ var MAX_BATCH_EXECUTE_FILE_BYTES = 5 * 1024 * 1024;
+// MARK: Coordinate key
+/**
+ * Builds the lookup key identifying a callModel dispatch coordinate. The factory indexes the
+ * caller's visible callModel tools by this key; the batch handler looks each operation up by the
+ * same key, so authorization reuses the exact tool set advertised on `tools/list`.
  *
- * 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, analyticsService) {
-        _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, "_logger", new common.Logger(McpServerFactoryService_1.name));
-        _define_property$3(this, "_cachedTools", void 0);
-        _define_property$3(this, "_cachedStaticTools", void 0);
-        _define_property$3(this, "_cachedManifest", void 0);
-        _define_property$3(this, "_cachedManifestModels", void 0);
-        _define_property$3(this, "_cachedManifestAuth", void 0);
-        _define_property$3(this, "_manifestLoaded", false);
-        _define_property$3(this, "_loggedSkips", false);
-        _define_property$3(this, "_warnedMissingRoleReader", false);
-        _define_property$3(this, "_analyticsService", void 0);
-        this.mcpConfig = mcpConfig;
-        this.dispatchService = dispatchService;
-        this.modelApiGetService = modelApiGetService;
-        this.roleReader = roleReader;
-        this._analyticsService = analyticsService !== null && analyticsService !== void 0 ? analyticsService : noopMcpAnalyticsService();
-    }
-    _create_class$3(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, _this_mcpConfig_serverInstructions;
-                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: (_this_mcpConfig_serverInstructions = this.mcpConfig.serverInstructions) !== null && _this_mcpConfig_serverInstructions !== void 0 ? _this_mcpConfig_serverInstructions : DEFAULT_MCP_SERVER_INSTRUCTIONS
-                });
-                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$2(toolGeneration.tools).concat(_to_consumable_array$2(staticTools));
-                var visibleTools = this._filterToolsForRequest(combinedTools, {
-                    ctx: ctx,
-                    scopes: scopes,
-                    authRoles: authRoles
-                });
-                var definitionsByName = new Map(visibleTools.map(function(tool) {
+ * @param dispatch - The `(call, modelType, specifier?)` coordinate to key.
+ * @returns A stable string key. Uses a NUL separator so segment values can't collide.
+ */ function batchOperationCoordKey(dispatch) {
+    var _dispatch_specifier;
+    return "".concat(dispatch.call, "\0").concat(dispatch.modelType, "\0").concat((_dispatch_specifier = dispatch.specifier) !== null && _dispatch_specifier !== void 0 ? _dispatch_specifier : '');
+}
+// MARK: Factory
+/**
+ * Builds the built-in `batch-execute` MCP tool definition.
+ *
+ * The tool ingests an uploaded JSON / NDJSON file of `(call, modelType, specifier?, data)`
+ * operations and runs them server-side, returning a single success/failure summary. It exists so an
+ * agent can perform a bulk mutation (e.g. "update 200 workers") by *generating* the operations file
+ * with a script and uploading it — rather than emitting each payload as tool-call output and paying
+ * one model turn per record.
+ *
+ * Safety model:
+ * - Every operation is validated and authorized against the caller's visible tool set *before any
+ *   dispatch*. A malformed or forbidden operation aborts the whole batch with a pre-flight error and
+ *   nothing runs — `dispatch` would otherwise bypass the `tools/list` visibility filter.
+ * - Runtime failures are best-effort by default (collected into the summary); `stopOnError` halts at
+ *   the first failure (forcing sequential execution).
+ *
+ * @param deps - Storage reader, dispatch fn, and per-operation authorizer (typically wired in the
+ *   server factory to the request's visible tool set).
+ * @returns A statically-registered {@link McpToolDefinition} ready to be appended to the MCP server
+ *   factory's tool registry.
+ */ function createBatchExecuteTool(deps) {
+    var handler = function handler(args, ctx) {
+        return batchExecuteToolHandler(args, ctx, deps);
+    };
+    var name = BATCH_EXECUTE_TOOL_NAME;
+    var description = 'Execute a batch of MCP operations server-side from an uploaded JSON/NDJSON file, returning a success/failure summary. Each line/element is an operation `{ call, modelType, specifier?, data }` matching any other write tool you could call individually. Generate the file with a script and upload it instead of invoking a per-record tool many times. Every operation is authorized against your visible tools before any run; a forbidden or malformed operation aborts the whole batch with nothing executed.';
+    return {
+        name: name,
+        description: description,
+        inputSchema: BATCH_EXECUTE_INPUT_SCHEMA,
+        outputSchema: BATCH_EXECUTE_OUTPUT_SCHEMA,
+        dispatch: {
+            call: BATCH_EXECUTE_DISPATCH_CALL,
+            modelType: BATCH_EXECUTE_DISPATCH_MODEL_TYPE
+        },
+        staticHandler: handler,
+        filterMetadata: {
+            visibilityKind: 'declarative',
+            rule: {
+                requireAuthenticated: true
+            },
+            effectiveReadOnly: false
+        },
+        staticWireEntry: buildStaticWireEntry({
+            name: name,
+            description: description,
+            inputSchema: BATCH_EXECUTE_INPUT_SCHEMA,
+            outputSchema: BATCH_EXECUTE_OUTPUT_SCHEMA
+        })
+    };
+}
+// MARK: Handler
+function batchExecuteToolHandler(args, ctx, deps) {
+    return _async_to_generator$3(function() {
+        var result, _deps_maxOperations, input, maxOperations, fileText, operations, preflightErrors, execution, failureCount, successCount, skippedCount, uploadDeleted, summary, error;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        4,
+                        ,
+                        5
+                    ]);
+                    input = parseBatchExecuteInput(args);
+                    maxOperations = (_deps_maxOperations = deps.maxOperations) !== null && _deps_maxOperations !== void 0 ? _deps_maxOperations : MAX_BATCH_EXECUTE_OPERATIONS;
                     return [
-                        tool.name,
-                        tool
-                    ];
+                        4,
+                        readOperationsFile({
+                            storageService: deps.storageService,
+                            uploadPath: input.uploadPath,
+                            bucketId: input.bucketId
+                        })
+                    ];
+                case 1:
+                    fileText = _state.sent();
+                    operations = parseOperations(fileText, input.format, maxOperations);
+                    // Pre-flight: validate + authorize every operation before any dispatch. dispatch() bypasses the
+                    // tools/list visibility filter, so an unauthorized operation must never reach it.
+                    preflightErrors = collectPreflightErrors(operations, deps.authorizeOperation);
+                    if (preflightErrors.length > 0) {
+                        throw new Error("batch-execute: ".concat(preflightErrors.length, " of ").concat(operations.length, " operation(s) failed pre-flight; nothing was executed. ").concat(describePreflightErrors(preflightErrors)));
+                    }
+                    return [
+                        4,
+                        executeOperations({
+                            operations: operations,
+                            input: input,
+                            ctx: ctx,
+                            dispatch: deps.dispatch
+                        })
+                    ];
+                case 2:
+                    execution = _state.sent();
+                    failureCount = execution.errors.length;
+                    successCount = execution.succeededCount;
+                    skippedCount = operations.length - successCount - failureCount;
+                    return [
+                        4,
+                        maybeDeleteUpload({
+                            storageService: deps.storageService,
+                            input: input,
+                            failureCount: failureCount
+                        })
+                    ];
+                case 3:
+                    uploadDeleted = _state.sent();
+                    summary = {
+                        total: operations.length,
+                        successCount: successCount,
+                        failureCount: failureCount,
+                        skippedCount: skippedCount,
+                        errors: execution.errors,
+                        uploadDeleted: uploadDeleted
+                    };
+                    result = {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(summary)
+                            }
+                        ],
+                        structuredContent: summary
+                    };
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    error = _state.sent();
+                    result = formatMcpToolErrorResponse(error);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+// MARK: Input parsing
+function parseBatchExecuteInput(args) {
+    var _args_format, _args_maxParallel;
+    var uploadPath = args.uploadPath;
+    if (typeof uploadPath !== 'string' || uploadPath.length === 0) {
+        throw new Error('batch-execute: "uploadPath" is required and must be a non-empty string.');
+    }
+    var bucketId = args.bucketId;
+    if (bucketId != null && (typeof bucketId !== 'string' || bucketId.length === 0)) {
+        throw new Error('batch-execute: "bucketId" must be a non-empty string when provided.');
+    }
+    var format = (_args_format = args.format) !== null && _args_format !== void 0 ? _args_format : 'ndjson';
+    if (format !== 'json' && format !== 'ndjson') {
+        throw new Error('batch-execute: "format" must be "json" or "ndjson".');
+    }
+    var maxParallel = (_args_maxParallel = args.maxParallel) !== null && _args_maxParallel !== void 0 ? _args_maxParallel : DEFAULT_BATCH_EXECUTE_MAX_PARALLEL;
+    if (typeof maxParallel !== 'number' || !Number.isInteger(maxParallel) || maxParallel < 1) {
+        throw new Error('batch-execute: "maxParallel" must be a positive integer.');
+    }
+    return {
+        uploadPath: uploadPath,
+        bucketId: bucketId !== null && bucketId !== void 0 ? bucketId : undefined,
+        format: format,
+        maxParallel: maxParallel,
+        stopOnError: args.stopOnError === true,
+        deleteUploadOnSuccess: args.deleteUploadOnSuccess !== false
+    };
+}
+function readOperationsFile(input) {
+    return _async_to_generator$3(function() {
+        var file, exists, bytes;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    file = input.storageService.file(toStoragePathInput(input.uploadPath, input.bucketId));
+                    return [
+                        4,
+                        file.exists()
+                    ];
+                case 1:
+                    exists = _state.sent();
+                    if (!exists) {
+                        throw new Error('batch-execute: operations file not found at "'.concat(input.uploadPath, '".'));
+                    }
+                    return [
+                        4,
+                        file.getBytes(MAX_BATCH_EXECUTE_FILE_BYTES)
+                    ];
+                case 2:
+                    bytes = _state.sent();
+                    return [
+                        2,
+                        Buffer.from(bytes).toString('utf8')
+                    ];
+            }
+        });
+    })();
+}
+// MARK: Operation parsing
+function parseOperations(fileText, format, maxOperations) {
+    var rawOperations = format === 'ndjson' ? parseNdjsonOperations(fileText) : parseJsonArrayOperations(fileText);
+    if (rawOperations.length === 0) {
+        throw new Error('batch-execute: the operations file contained no operations.');
+    }
+    if (rawOperations.length > maxOperations) {
+        throw new Error("batch-execute: ".concat(rawOperations.length, " operations exceed the limit of ").concat(maxOperations, "."));
+    }
+    return rawOperations.map(function(value, index) {
+        return validateOperation(value, index);
+    });
+}
+function parseNdjsonOperations(fileText) {
+    var operations = [];
+    fileText.split('\n').forEach(function(line, lineIndex) {
+        var trimmed = line.trim();
+        if (trimmed.length > 0) {
+            try {
+                operations.push(JSON.parse(trimmed));
+            } catch (error) {
+                throw new Error("batch-execute: invalid JSON on line ".concat(lineIndex + 1, ": ").concat(error.message), {
+                    cause: error
+                });
+            }
+        }
+    });
+    return operations;
+}
+function parseJsonArrayOperations(fileText) {
+    var parsed;
+    try {
+        parsed = JSON.parse(fileText);
+    } catch (error) {
+        throw new Error("batch-execute: file is not valid JSON: ".concat(error.message), {
+            cause: error
+        });
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error('batch-execute: with format "json" the file must contain a top-level array of operations.');
+    }
+    return parsed;
+}
+function validateOperation(value, index) {
+    if (value == null || (typeof value === "undefined" ? "undefined" : _type_of$1(value)) !== 'object') {
+        throw new Error("batch-execute: operation[".concat(index, "] must be an object."));
+    }
+    var candidate = value;
+    var modelType = candidate.modelType;
+    var call = candidate.call;
+    var specifier = candidate.specifier;
+    if (typeof modelType !== 'string' || modelType.length === 0) {
+        throw new Error("batch-execute: operation[".concat(index, '] is missing a non-empty "modelType".'));
+    }
+    if (typeof call !== 'string' || call.length === 0) {
+        throw new Error("batch-execute: operation[".concat(index, '] is missing a non-empty "call".'));
+    }
+    if (specifier != null && typeof specifier !== 'string') {
+        throw new Error("batch-execute: operation[".concat(index, '] "specifier" must be a string when provided.'));
+    }
+    return {
+        call: call,
+        modelType: modelType,
+        specifier: specifier !== null && specifier !== void 0 ? specifier : undefined,
+        data: candidate.data
+    };
+}
+function collectPreflightErrors(operations, authorizeOperation) {
+    var errors = [];
+    operations.forEach(function(operation, index) {
+        var authorization = authorizeOperation(operation);
+        if (!authorization.allowed) {
+            var _operation_call;
+            errors.push({
+                index: index,
+                modelType: operation.modelType,
+                call: (_operation_call = operation.call) !== null && _operation_call !== void 0 ? _operation_call : undefined,
+                specifier: operation.specifier,
+                reason: authorization.reason
+            });
+        }
+    });
+    return errors;
+}
+function describePreflightErrors(errors) {
+    var sample = errors.slice(0, 5).map(function(error) {
+        var _error_call;
+        var specifierSuffix = error.specifier ? "/".concat(error.specifier) : '';
+        return "[".concat(error.index, "] ").concat((_error_call = error.call) !== null && _error_call !== void 0 ? _error_call : '?', "/").concat(error.modelType).concat(specifierSuffix, ": ").concat(error.reason);
+    }).join('; ');
+    var suffix = errors.length > 5 ? " (+".concat(errors.length - 5, " more)") : '';
+    return "".concat(sample).concat(suffix);
+}
+function executeOperations(input) {
+    return _async_to_generator$3(function() {
+        return _ts_generator$3(this, function(_state) {
+            return [
+                2,
+                input.input.stopOnError ? executeSequentialStopOnError(input) : executeBestEffort(input)
+            ];
+        });
+    })();
+}
+function executeBestEffort(input) {
+    return _async_to_generator$3(function() {
+        var operations, ctx, dispatch, indices, taskResult, errors;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    operations = input.operations, ctx = input.ctx, dispatch = input.dispatch;
+                    indices = operations.map(function(_, index) {
+                        return index;
+                    });
+                    return [
+                        4,
+                        util.performAsyncTasks(indices, function(index) {
+                            return _async_to_generator$3(function() {
+                                var entry, error;
+                                return _ts_generator$3(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            _state.trys.push([
+                                                0,
+                                                2,
+                                                ,
+                                                3
+                                            ]);
+                                            return [
+                                                4,
+                                                dispatch(operations[index], ctx.auth, ctx.rawRequest)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                3,
+                                                3
+                                            ];
+                                        case 2:
+                                            error = _state.sent();
+                                            entry = toErrorEntry(operations[index], index, error);
+                                            return [
+                                                3,
+                                                3
+                                            ];
+                                        case 3:
+                                            return [
+                                                2,
+                                                entry
+                                            ];
+                                    }
+                                });
+                            })();
+                        }, {
+                            throwError: false,
+                            maxParallelTasks: input.input.maxParallel
+                        })
+                    ];
+                case 1:
+                    taskResult = _state.sent();
+                    errors = taskResult.results.map(function(param) {
+                        var _param = _sliced_to_array$1(param, 2), entry = _param[1];
+                        return entry;
+                    }).filter(function(entry) {
+                        return entry != null;
+                    }).sort(function(a, b) {
+                        return a.index - b.index;
+                    });
+                    return [
+                        2,
+                        {
+                            succeededCount: operations.length - errors.length,
+                            errors: errors
+                        }
+                    ];
+            }
+        });
+    })();
+}
+function executeSequentialStopOnError(input) {
+    return _async_to_generator$3(function() {
+        var operations, ctx, dispatch, errors, succeededCount, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, index, operation, error, err;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    operations = input.operations, ctx = input.ctx, dispatch = input.dispatch;
+                    errors = [];
+                    succeededCount = 0;
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        8,
+                        9,
+                        10
+                    ]);
+                    _iterator = operations.entries()[Symbol.iterator]();
+                    _state.label = 2;
+                case 2:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        7
+                    ];
+                    _step_value = _sliced_to_array$1(_step.value, 2), index = _step_value[0], operation = _step_value[1];
+                    _state.label = 3;
+                case 3:
+                    _state.trys.push([
+                        3,
+                        5,
+                        ,
+                        6
+                    ]);
+                    return [
+                        4,
+                        dispatch(operation, ctx.auth, ctx.rawRequest)
+                    ];
+                case 4:
+                    _state.sent();
+                    succeededCount += 1;
+                    return [
+                        3,
+                        6
+                    ];
+                case 5:
+                    error = _state.sent();
+                    errors.push(toErrorEntry(operation, index, error));
+                    return [
+                        3,
+                        7
+                    ];
+                case 6:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        2
+                    ];
+                case 7:
+                    return [
+                        3,
+                        10
+                    ];
+                case 8:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        10
+                    ];
+                case 9:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 10:
+                    return [
+                        2,
+                        {
+                            succeededCount: succeededCount,
+                            errors: errors
+                        }
+                    ];
+            }
+        });
+    })();
+}
+function toErrorEntry(operation, index, error) {
+    var _operation_call;
+    return {
+        index: index,
+        modelType: operation.modelType,
+        call: (_operation_call = operation.call) !== null && _operation_call !== void 0 ? _operation_call : undefined,
+        specifier: operation.specifier,
+        message: _instanceof(error, Error) ? error.message : String(error)
+    };
+}
+function maybeDeleteUpload(input) {
+    return _async_to_generator$3(function() {
+        var deleted, file;
+        return _ts_generator$3(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    deleted = false;
+                    if (!(input.input.deleteUploadOnSuccess && input.failureCount === 0)) return [
+                        3,
+                        2
+                    ];
+                    file = input.storageService.file(toStoragePathInput(input.input.uploadPath, input.input.bucketId));
+                    return [
+                        4,
+                        file.delete()
+                    ];
+                case 1:
+                    _state.sent();
+                    deleted = true;
+                    _state.label = 2;
+                case 2:
+                    return [
+                        2,
+                        deleted
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Builds a {@link StoragePathInput} from a path + optional bucket. Omits `bucketId` entirely when
+ * absent (rather than passing `undefined`) so the accessor falls back to the app default bucket.
+ *
+ * @param pathString - The slash path of the file within the bucket.
+ * @param bucketId - The bucket id, or `undefined` for the default bucket.
+ * @returns The resolved storage path input.
+ */ function toStoragePathInput(pathString, bucketId) {
+    return bucketId != null ? {
+        bucketId: bucketId,
+        pathString: pathString
+    } : {
+        pathString: pathString
+    };
+}
+// MARK: Schemas
+var BATCH_EXECUTE_INPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'uploadPath'
+    ],
+    properties: {
+        uploadPath: {
+            type: 'string',
+            minLength: 1,
+            description: 'Storage path of the uploaded operations file (JSON array or NDJSON).'
+        },
+        bucketId: {
+            type: 'string',
+            minLength: 1,
+            description: 'Storage bucket id. Defaults to the app default bucket when omitted.'
+        },
+        format: {
+            type: 'string',
+            enum: [
+                'json',
+                'ndjson'
+            ],
+            description: 'File format. "ndjson" (default) = one operation per line; "json" = a top-level array.'
+        },
+        maxParallel: {
+            type: 'integer',
+            minimum: 1,
+            description: "Operations dispatched concurrently. Defaults to ".concat(DEFAULT_BATCH_EXECUTE_MAX_PARALLEL, ". Ignored (forced to sequential) when stopOnError is true.")
+        },
+        stopOnError: {
+            type: 'boolean',
+            description: 'Halt at the first runtime failure (runs sequentially). Defaults to false (best-effort; all operations attempted).'
+        },
+        deleteUploadOnSuccess: {
+            type: 'boolean',
+            description: 'Delete the uploaded file when every operation succeeds. Defaults to true. The file is always kept when any operation fails.'
+        }
+    },
+    additionalProperties: false
+};
+var BATCH_EXECUTE_OUTPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'total',
+        'successCount',
+        'failureCount',
+        'skippedCount',
+        'errors',
+        'uploadDeleted'
+    ],
+    properties: {
+        total: {
+            type: 'integer',
+            description: 'Total operations in the file.'
+        },
+        successCount: {
+            type: 'integer',
+            description: 'Operations that succeeded.'
+        },
+        failureCount: {
+            type: 'integer',
+            description: 'Operations that failed at runtime.'
+        },
+        skippedCount: {
+            type: 'integer',
+            description: 'Operations not attempted (only non-zero when stopOnError halted the run early).'
+        },
+        errors: {
+            type: 'array',
+            description: 'Per-operation runtime failures, keyed by original file index.',
+            items: {
+                type: 'object',
+                required: [
+                    'index',
+                    'modelType',
+                    'message'
+                ],
+                properties: {
+                    index: {
+                        type: 'integer'
+                    },
+                    modelType: {
+                        type: 'string'
+                    },
+                    call: {
+                        type: 'string'
+                    },
+                    specifier: {
+                        type: 'string'
+                    },
+                    message: {
+                        type: 'string'
+                    }
+                }
+            }
+        },
+        uploadDeleted: {
+            type: 'boolean',
+            description: 'Whether the uploaded operations file was deleted after the run.'
+        }
+    }
+};
+
+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(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 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$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$3(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$3(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+    return Constructor;
+}
+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(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$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 _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest();
+}
+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);
+}
+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, analyticsService, storageService) {
+        _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, "_logger", new common.Logger(McpServerFactoryService_1.name));
+        _define_property$3(this, "_cachedTools", void 0);
+        _define_property$3(this, "_cachedStaticTools", void 0);
+        _define_property$3(this, "_cachedManifest", void 0);
+        _define_property$3(this, "_cachedManifestModels", void 0);
+        _define_property$3(this, "_cachedManifestAuth", void 0);
+        _define_property$3(this, "_manifestLoaded", false);
+        _define_property$3(this, "_loggedSkips", false);
+        _define_property$3(this, "_warnedMissingRoleReader", false);
+        _define_property$3(this, "_analyticsService", void 0);
+        this.mcpConfig = mcpConfig;
+        this.dispatchService = dispatchService;
+        this.modelApiGetService = modelApiGetService;
+        this.roleReader = roleReader;
+        this.storageService = storageService;
+        this._analyticsService = analyticsService !== null && analyticsService !== void 0 ? analyticsService : noopMcpAnalyticsService();
+    }
+    _create_class$3(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, _this_mcpConfig_serverInstructions;
+                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: (_this_mcpConfig_serverInstructions = this.mcpConfig.serverInstructions) !== null && _this_mcpConfig_serverInstructions !== void 0 ? _this_mcpConfig_serverInstructions : DEFAULT_MCP_SERVER_INSTRUCTIONS
+                });
+                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$2(toolGeneration.tools).concat(_to_consumable_array$2(staticTools));
+                var visibleTools = this._filterToolsForRequest(combinedTools, {
+                    ctx: ctx,
+                    scopes: scopes,
+                    authRoles: authRoles
+                });
+                var definitionsByName = new Map(visibleTools.map(function(tool) {
+                    return [
+                        tool.name,
+                        tool
+                    ];
                 }));
+                // The batch tool is request-scoped: it authorizes each batched operation against this caller's
+                // resolved visible tool set, so it can't be cached like the other static tools.
+                var batchTool = this._resolveBatchTool(ctx, definitionsByName);
+                var listedTools = visibleTools;
+                if (batchTool != null) {
+                    definitionsByName.set(batchTool.name, batchTool);
+                    listedTools = _to_consumable_array$2(visibleTools).concat([
+                        batchTool
+                    ]);
+                }
                 server.server.setRequestHandler(types_js.ListToolsRequestSchema, function() {
                     return _async_to_generator$2(function() {
                         var _this;
@@ -3267,7 +4136,7 @@ var McpServerFactoryService_1;
                             return [
                                 2,
                                 {
-                                    tools: visibleTools.map(function(tool) {
+                                    tools: listedTools.map(function(tool) {
                                         return _this._buildToolListEntry(tool, ctx, scopes);
                                     })
                                 }
@@ -3528,6 +4397,92 @@ var McpServerFactoryService_1;
         },
         {
             /**
+     * Builds the per-request `batch-execute` tool, or `undefined` when it should not be offered.
+     *
+     * Unlike the cached static tools this is rebuilt per request, because it closes over the caller's
+     * resolved visible tool set: each batched operation is authorized against exactly the callModel
+     * tools this caller may invoke directly. Offered only when a storage service is wired (it reads
+     * the uploaded operations file), the caller is authenticated, and the server is not in read-only
+     * mode (the tool performs writes).
+     *
+     * @param ctx - The per-request context (auth, raw request) forwarded to dispatched operations.
+     * @param definitionsByName - The caller's visible tool definitions, keyed by name.
+     * @returns The batch tool definition, or `undefined` when unavailable for this request.
+     */ key: "_resolveBatchTool",
+            value: function _resolveBatchTool(ctx, definitionsByName) {
+                var _this = this;
+                var result;
+                var storageService = this.storageService;
+                if (storageService != null && ctx.auth != null && this.mcpConfig.readOnly !== true) {
+                    var authorizedCoords = new Set();
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = definitionsByName.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var definition = _step.value;
+                            // Only callModel tools are re-dispatchable; static tools (model-get, whoami) have synthetic
+                            // dispatch identities the callModel chain can't resolve.
+                            if (definition.staticHandler == null) {
+                                authorizedCoords.add(batchOperationCoordKey(definition.dispatch));
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    result = createBatchExecuteTool({
+                        storageService: storageService,
+                        dispatch: function dispatch(operation, auth, rawRequest) {
+                            return _this.dispatchService.dispatch(operation, auth, rawRequest);
+                        },
+                        authorizeOperation: function authorizeOperation(operation) {
+                            return _this._authorizeBatchOperation(operation, authorizedCoords);
+                        }
+                    });
+                }
+                return result;
+            }
+        },
+        {
+            /**
+     * Authorizes a single batched operation against the caller's visible callModel tool coordinates.
+     *
+     * Re-applies the same gate the `tools/list` filter already enforced: an operation is allowed only
+     * when its `(call, modelType, specifier)` coordinate matches a tool this caller can see. This is
+     * the critical guard — `dispatchService.dispatch` bypasses the MCP visibility filter, so without
+     * this check a batch could reach scope-, role-, or read-only-gated handlers.
+     *
+     * @param operation - The operation to authorize.
+     * @param authorizedCoords - The set of dispatchable coordinate keys visible to this caller.
+     * @returns Whether the operation may be dispatched, with a reason when it may not.
+     */ key: "_authorizeBatchOperation",
+            value: function _authorizeBatchOperation(operation, authorizedCoords) {
+                var _operation_call, _operation_specifier, _operation_call1;
+                var coordKey = batchOperationCoordKey({
+                    call: (_operation_call = operation.call) !== null && _operation_call !== void 0 ? _operation_call : '',
+                    modelType: operation.modelType,
+                    specifier: (_operation_specifier = operation.specifier) !== null && _operation_specifier !== void 0 ? _operation_specifier : undefined
+                });
+                var specifierSuffix = operation.specifier ? ' specifier="'.concat(operation.specifier, '"') : '';
+                return authorizedCoords.has(coordKey) ? {
+                    allowed: true
+                } : {
+                    allowed: false,
+                    reason: 'no visible tool matches call="'.concat((_operation_call1 = operation.call) !== null && _operation_call1 !== void 0 ? _operation_call1 : '', '" modelType="').concat(operation.modelType, '"').concat(specifierSuffix, " (unknown, or hidden by scope/role/read-only).")
+                };
+            }
+        },
+        {
+            /**
      * 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.
      *
@@ -4019,7 +4974,9 @@ exports.McpServerFactoryService = McpServerFactoryService_1 = __decorate([
     __param(3, common.Optional()),
     __param(3, common.Inject(MCP_AUTH_ROLE_READER)),
     __param(4, common.Optional()),
-    __param(4, common.Inject(MCP_ANALYTICS_SERVICE))
+    __param(4, common.Inject(MCP_ANALYTICS_SERVICE)),
+    __param(5, common.Optional()),
+    __param(5, common.Inject(firebaseServer.FirebaseServerStorageService))
 ], exports.McpServerFactoryService);
 
 function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
@@ -4811,6 +5768,10 @@ function _unsupported_iterable_to_array(o, minLen) {
     };
 }
 
+exports.BATCH_EXECUTE_DISPATCH_CALL = BATCH_EXECUTE_DISPATCH_CALL;
+exports.BATCH_EXECUTE_DISPATCH_MODEL_TYPE = BATCH_EXECUTE_DISPATCH_MODEL_TYPE;
+exports.BATCH_EXECUTE_TOOL_NAME = BATCH_EXECUTE_TOOL_NAME;
+exports.DEFAULT_BATCH_EXECUTE_MAX_PARALLEL = DEFAULT_BATCH_EXECUTE_MAX_PARALLEL;
 exports.DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS = DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS;
 exports.DEFAULT_MCP_ANALYTICS_EVENT_NAME = DEFAULT_MCP_ANALYTICS_EVENT_NAME;
 exports.DEFAULT_MCP_PATH = DEFAULT_MCP_PATH;
@@ -4820,6 +5781,8 @@ exports.DEFAULT_SPECIFIER_KEY = DEFAULT_SPECIFIER_KEY;
 exports.DEFAULT_VOID_MCP_SUCCESS_VALUE = DEFAULT_VOID_MCP_SUCCESS_VALUE;
 exports.FIREBASE_SERVER_MCP_ANALYTICS_CONFIG = FIREBASE_SERVER_MCP_ANALYTICS_CONFIG;
 exports.FIREBASE_SERVER_MCP_ROUTES_FOR_GLOBAL_ROUTE_EXCLUDE = FIREBASE_SERVER_MCP_ROUTES_FOR_GLOBAL_ROUTE_EXCLUDE;
+exports.MAX_BATCH_EXECUTE_FILE_BYTES = MAX_BATCH_EXECUTE_FILE_BYTES;
+exports.MAX_BATCH_EXECUTE_OPERATIONS = MAX_BATCH_EXECUTE_OPERATIONS;
 exports.MCP_ANALYTICS_SERVICE = MCP_ANALYTICS_SERVICE;
 exports.MCP_AUTH_ROLE_READER = MCP_AUTH_ROLE_READER;
 exports.MCP_CALL_TYPE_ABBREVIATIONS = MCP_CALL_TYPE_ABBREVIATIONS;
@@ -4842,11 +5805,13 @@ exports.McpAnalyticsService = McpAnalyticsService;
 exports.McpModuleConfig = McpModuleConfig;
 exports.abbreviateMcpCallType = abbreviateMcpCallType;
 exports.appMcpAnalyticsModuleMetadata = appMcpAnalyticsModuleMetadata;
+exports.batchOperationCoordKey = batchOperationCoordKey;
 exports.buildDefaultMcpToolDescription = buildDefaultMcpToolDescription;
 exports.buildDisambiguatedMcpToolName = buildDisambiguatedMcpToolName;
 exports.buildMcpToolName = buildMcpToolName;
 exports.buildStaticWireEntry = buildStaticWireEntry;
 exports.classifyVisibility = classifyVisibility;
+exports.createBatchExecuteTool = createBatchExecuteTool;
 exports.createModelDecodeTool = createModelDecodeTool;
 exports.createModelGetTool = createModelGetTool;
 exports.createModelInfoTool = createModelInfoTool;