@dereekb/firebase-server 13.13.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,36 @@ function _class_call_check$4(instance, Constructor) {
     return isDefault ? "".concat(modelType, ".").concat(call, "._") : "".concat(modelType, ".").concat(call, ".").concat(specifier);
 }
 
-function _instanceof(left, right) {
+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 _instanceof$1(left, right) {
     "@swc/helpers - instanceof";
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -200,6 +229,105 @@ function _instanceof(left, right) {
         return left instanceof right;
     }
 }
+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
+        };
+    }
+}
 /**
  * Default structured value emitted by MCP when a handler returns `undefined`.
  *
@@ -212,46 +340,84 @@ function _instanceof(left, right) {
 /**
  * Resolves a dispatch result + handler API details into the MCP `CallToolResult` shape.
  *
+ * When `mcp.mapSuccessfulResult` is set, the raw result is first mapped (async-capable) to the value
+ * exposed via MCP; the tiers and the default path then operate on the mapped value. The tier
+ * callbacks receive `(value, context)` where `context` carries both the raw + mapped values + params.
+ *
  * Three-tier resolution as documented on {@link OnCallModelFunctionApiDetails.mcp}:
  *
  * - **Tier 3** — when `mcp.formatResponse` is set, its return value is used verbatim.
  * - **Tier 2** — when `mcp.summarizeResponse` is set, the summary string is wrapped into a
- *   single text content block with the raw `result` exposed as `structuredContent`.
- * - **Tier 1** — default: JSON-stringify `result` as a single text content block, also
- *   exposing the raw value as `structuredContent`.
+ *   single text content block with the (mapped) value exposed as `structuredContent`.
+ * - **Tier 1** — default: JSON-stringify the (mapped) value as a single text content block, also
+ *   exposing it as `structuredContent`.
  *
- * @param result - The handler's return value.
+ * @param result - The handler's raw return value.
  * @param params - The {@link OnCallTypedModelParams} that were dispatched.
- * @param details - The handler-level API details (carries Tier 2/3 formatters).
+ * @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) {
-    var mcp = details === null || details === void 0 ? void 0 : details.mcp;
-    var response;
-    if (mcp === null || mcp === void 0 ? void 0 : mcp.formatResponse) {
-        response = mcp.formatResponse(result, params);
-    } else if (mcp === null || mcp === void 0 ? void 0 : mcp.summarizeResponse) {
-        var summary = mcp.summarizeResponse(result, params);
-        response = {
-            content: [
-                {
-                    type: 'text',
-                    text: summary
-                }
-            ],
-            structuredContent: result
-        };
-    } else {
-        response = {
-            content: [
-                {
-                    type: 'text',
-                    text: stringifyResult(result)
-                }
-            ],
-            structuredContent: result === undefined ? DEFAULT_VOID_MCP_SUCCESS_VALUE : result
-        };
-    }
-    return response;
+    return _async_to_generator$5(function() {
+        var mcp, value, _tmp, context, response, summary;
+        return _ts_generator$5(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    mcp = details === null || details === void 0 ? void 0 : details.mcp;
+                    if (!(mcp === null || mcp === void 0 ? void 0 : mcp.mapSuccessfulResult)) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        mcp.mapSuccessfulResult(result, params)
+                    ];
+                case 1:
+                    _tmp = _state.sent();
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    _tmp = result;
+                    _state.label = 3;
+                case 3:
+                    value = _tmp;
+                    context = {
+                        raw: result,
+                        value: value,
+                        params: params
+                    };
+                    if (mcp === null || mcp === void 0 ? void 0 : mcp.formatResponse) {
+                        response = mcp.formatResponse(value, context);
+                    } else if (mcp === null || mcp === void 0 ? void 0 : mcp.summarizeResponse) {
+                        summary = mcp.summarizeResponse(value, context);
+                        response = {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: summary
+                                }
+                            ],
+                            structuredContent: value
+                        };
+                    } else {
+                        response = {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: stringifyResult(value)
+                                }
+                            ],
+                            structuredContent: value === undefined ? DEFAULT_VOID_MCP_SUCCESS_VALUE : value
+                        };
+                    }
+                    return [
+                        2,
+                        response
+                    ];
+            }
+        });
+    })();
 }
 /**
  * Converts an error thrown from the dispatch chain into the MCP error response shape.
@@ -259,7 +425,7 @@ function _instanceof(left, right) {
  * @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: [
@@ -357,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 = [];
@@ -389,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.
@@ -458,18 +624,124 @@ function _unsupported_iterable_to_array$6(o, minLen) {
  * The default specifier key used when a handler is not behind a specifier router.
  */ var DEFAULT_SPECIFIER_KEY = '_';
 /**
- * Builds the MCP tool name for a (modelType, callType, specifier) triple.
+ * Soft limit for an MCP tool name. Names longer than this still register, but the generator
+ * surfaces a `name_length_warning` so the drift toward the hard cap is visible at boot / build.
+ */ var MCP_TOOL_NAME_WARN_LENGTH = 55;
+/**
+ * Hard limit for an MCP tool name. Remote MCP clients reject a `tools/list` payload that contains
+ * any tool whose `name` exceeds this (`FrontendRemoteMcpToolDefinition.name: String should have at
+ * most 64 characters`), which fails the whole connection. Names over this are not registered.
+ */ var MCP_TOOL_NAME_MAX_LENGTH = 64;
+/**
+ * Classifies a tool name's length against the soft/hard MCP name-length limits.
+ *
+ * Shared by the runtime generator and the build-time manifest renderer so both apply the
+ * same thresholds and never drift.
+ *
+ * @param name - The fully-resolved tool name (including any per-handler override).
+ * @returns The length classification — `error` over {@link MCP_TOOL_NAME_MAX_LENGTH}, `warn` over
+ *   {@link MCP_TOOL_NAME_WARN_LENGTH}, otherwise `ok`.
+ *
+ * @example
+ * ```ts
+ * validateMcpToolName('worker-create'); // { name: 'worker-create', length: 13, level: 'ok' }
+ * ```
+ */ function validateMcpToolName(name) {
+    var length = name.length;
+    var level = 'ok';
+    if (length > MCP_TOOL_NAME_MAX_LENGTH) {
+        level = 'error';
+    } else if (length > MCP_TOOL_NAME_WARN_LENGTH) {
+        level = 'warn';
+    }
+    return {
+        name: name,
+        length: length,
+        level: level
+    };
+}
+/**
+ * Builds the MCP tool name for a (modelSegment, callType, specifier) triple.
  *
- * Apps can override the auto-generated name by setting
- * {@link OnCallModelFunctionApiDetails.mcp.name} on the handler.
+ * The call-type segment is only emitted for the default (`_`) specifier, where it carries the
+ * meaning (`worker-create`, `worker-update`). Named specifiers drop it — the specifier already
+ * disambiguates (`worker-syncCheckHqEmployee`), which keeps names short and within the MCP
+ * 64-character cap. Apps can override the whole name per handler via
+ * {@link OnCallModelFunctionApiDetails.mcp.name}.
  *
- * @param modelType - The Firestore model type (e.g., `storageFile`).
+ * This is the preferred (short) form. When two visible tools collide on it — two call types share a
+ * specifier once the call-type segment is dropped — the generator re-derives both names with
+ * {@link buildDisambiguatedMcpToolName} instead.
+ *
+ * @param modelSegment - The model segment of the name. Defaults to the model type, but may be a
+ *   shorter per-model override (e.g. the collection prefix) resolved by the caller.
  * @param callType - The call type (e.g., `invoke`).
  * @param specifier - The specifier key, or `_` / undefined for the default entry.
  * @returns The hyphen-joined tool name advertised on `tools/list`.
- */ function buildMcpToolName(modelType, callType, specifier) {
+ *
+ * @example
+ * ```ts
+ * buildMcpToolName('worker', 'create'); // 'worker-create'
+ * buildMcpToolName('worker', 'update', 'syncCheckHqEmployee'); // 'worker-syncCheckHqEmployee'
+ * ```
+ */ function buildMcpToolName(modelSegment, callType, specifier) {
+    var isDefault = specifier == null || specifier === DEFAULT_SPECIFIER_KEY;
+    return isDefault ? "".concat(modelSegment, "-").concat(callType) : "".concat(modelSegment, "-").concat(specifier);
+}
+/**
+ * Single-character abbreviations for the standard CRUDQ + invoke call types, used to disambiguate
+ * colliding tool names without re-introducing the full call-type segment everywhere.
+ *
+ * @example
+ * ```ts
+ * MCP_CALL_TYPE_ABBREVIATIONS.update; // 'u'
+ * ```
+ */ var MCP_CALL_TYPE_ABBREVIATIONS = {
+    create: 'c',
+    read: 'r',
+    update: 'u',
+    delete: 'd',
+    query: 'q',
+    invoke: 'i'
+};
+/**
+ * Abbreviates a call type for use in a disambiguated tool name. Known CRUDQ + invoke types collapse
+ * to a single character; a custom call type is returned unchanged so the name stays unambiguous.
+ *
+ * @param callType - The call type / verb.
+ * @returns The single-character abbreviation, or the original string for a custom call type.
+ *
+ * @example
+ * ```ts
+ * abbreviateMcpCallType('update'); // 'u'
+ * abbreviateMcpCallType('recompute'); // 'recompute'
+ * ```
+ */ function abbreviateMcpCallType(callType) {
+    var _MCP_CALL_TYPE_ABBREVIATIONS_callType;
+    return (_MCP_CALL_TYPE_ABBREVIATIONS_callType = MCP_CALL_TYPE_ABBREVIATIONS[callType]) !== null && _MCP_CALL_TYPE_ABBREVIATIONS_callType !== void 0 ? _MCP_CALL_TYPE_ABBREVIATIONS_callType : callType;
+}
+/**
+ * Builds the disambiguated MCP tool name for a (modelSegment, callType, specifier) triple — the form
+ * used only when the preferred {@link buildMcpToolName} output collides with another visible tool.
+ *
+ * Named specifiers re-insert the call type, abbreviated, between the segment and specifier
+ * (`worker-u-syncCheckHqEmployee`); since the two colliding tools differ only by call type, their
+ * abbreviations differ and the names no longer clash. Default (`_`) specifiers already carry the
+ * full call type, so they are returned in their {@link buildMcpToolName} form unchanged.
+ *
+ * @param modelSegment - The model segment of the name (model type, or a per-model override).
+ * @param callType - The call type / verb.
+ * @param specifier - The specifier key, or `_` / undefined for the default entry.
+ * @returns The hyphen-joined disambiguated tool name.
+ *
+ * @example
+ * ```ts
+ * buildDisambiguatedMcpToolName('worker', 'update', 'syncCheckHqEmployee'); // 'worker-u-syncCheckHqEmployee'
+ * buildDisambiguatedMcpToolName('worker', 'create'); // 'worker-create'
+ * ```
+ */ function buildDisambiguatedMcpToolName(modelSegment, callType, specifier) {
     var isDefault = specifier == null || specifier === DEFAULT_SPECIFIER_KEY;
-    return isDefault ? "".concat(modelType, "-").concat(callType) : "".concat(modelType, "-").concat(callType, "-").concat(specifier);
+    return isDefault ? "".concat(modelSegment, "-").concat(callType) : "".concat(modelSegment, "-").concat(abbreviateMcpCallType(callType), "-").concat(specifier);
 }
 /**
  * Builds the default description used when no build-time MCP manifest
@@ -483,7 +755,6 @@ function _unsupported_iterable_to_array$6(o, minLen) {
     var isDefault = specifier == null || specifier === DEFAULT_SPECIFIER_KEY;
     return isDefault ? 'Performs the "'.concat(callType, '" call on the "').concat(modelType, '" model.') : 'Performs the "'.concat(callType, '" call on the "').concat(modelType, '" model with the "').concat(specifier, '" specifier.');
 }
-// MARK: Generation
 /**
  * Generates MCP tool definitions from a model-first API details tree.
  *
@@ -491,38 +762,136 @@ function _unsupported_iterable_to_array$6(o, minLen) {
  * `inputType.toJsonSchema(options)` for the schema, and applies any handler-level
  * MCP `name` override. Descriptions and input/output schemas are pulled from the
  * build-time manifest when supplied. Tools without an `inputType` are skipped and
- * reported so callers can log the gap at startup.
+ * reported so callers can log the gap at startup. Tools whose resolved name exceeds
+ * {@link MCP_TOOL_NAME_MAX_LENGTH} are skipped so the advertised `tools/list` stays valid.
+ *
+ * Generation runs in two passes so a name clash is known before any name is finalized: the first
+ * pass plans every candidate and counts how many visible auto-named tools share each preferred name;
+ * the second builds each tool, re-deriving the colliding ones with the abbreviated call type
+ * ({@link buildDisambiguatedMcpToolName}) so both survive instead of one shadowing the other. A
+ * residual collision that disambiguation cannot resolve (e.g. an `mcp.name` override matching an auto
+ * name) drops the later tool so the dispatch map stays unambiguous.
  *
  * @param apiDetails - The model-first API details tree returned by `getModelApiDetails(callModelFn)`.
  * @param options - Optional schema generation options forwarded to `toJsonSchema()`. Defaults to {@link DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS}.
- * @param manifest - Optional build-time manifest map; supplies overrides for descriptions and input/output schemas keyed by {@link mcpManifestKey}.
+ * @param context - Optional build-time context (manifest overrides + per-model name segments).
  * @returns The list of generated tool definitions plus any skip reports.
  */ function generateMcpToolDefinitions(apiDetails) {
-    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS, manifest = arguments.length > 2 ? arguments[2] : void 0;
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_JSON_SCHEMA_GENERATION_OPTIONS, context = arguments.length > 2 ? arguments[2] : void 0;
     var tools = [];
     var neverVisibleTools = [];
     var skipped = [];
+    var warnings = [];
+    var seenNames = new Set();
+    var manifest = context === null || context === void 0 ? void 0 : context.manifest;
+    var naming = context === null || context === void 0 ? void 0 : context.naming;
+    var candidates = planMcpToolCandidates(apiDetails, naming);
+    var clashCounts = countVisibleAutoNameClashes(candidates);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = candidates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var candidate = _step.value;
+            buildToolFromCandidate({
+                candidate: candidate,
+                clashCounts: clashCounts,
+                options: options,
+                manifest: manifest,
+                seenNames: seenNames,
+                outTools: tools,
+                outNeverVisibleTools: neverVisibleTools,
+                outSkipped: skipped,
+                outWarnings: warnings
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return {
+        tools: tools,
+        neverVisibleTools: neverVisibleTools,
+        skipped: skipped,
+        warnings: warnings
+    };
+}
+/**
+ * First pass: walk the API tree and plan one {@link McpToolCandidate} per handler. No schema
+ * generation happens here — only the cheap naming + visibility classification needed to detect
+ * clashes before any name is finalized.
+ *
+ * @param apiDetails - The model-first API details tree.
+ * @param naming - Optional per-model name-segment overrides.
+ * @returns One candidate per non-null handler, in tree order.
+ */ function planMcpToolCandidates(apiDetails, naming) {
+    var candidates = [];
     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;
                     }
-                    generateToolsForModelCall({
-                        modelType: modelType,
-                        callType: callType,
-                        callDetails: callDetails,
-                        options: options,
-                        manifest: manifest,
-                        outTools: tools,
-                        outNeverVisibleTools: neverVisibleTools,
-                        outSkipped: skipped
-                    });
+                    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$3(_step2.value, 2), specifierKey = _step_value2[0], handlerDetails = _step_value2[1];
+                            var _ref;
+                            var _naming_modelSegments, _handlerDetails_mcp, _handlerDetails_mcp1;
+                            if (handlerDetails == null) {
+                                continue;
+                            }
+                            var specifier = callDetails.isSpecifier ? specifierKey : undefined;
+                            var dispatch = {
+                                call: callType,
+                                modelType: modelType,
+                                specifier: specifier
+                            };
+                            var modelSegment = (_ref = naming === null || naming === void 0 ? void 0 : (_naming_modelSegments = naming.modelSegments) === null || _naming_modelSegments === void 0 ? void 0 : _naming_modelSegments.get(modelType)) !== null && _ref !== void 0 ? _ref : modelType;
+                            var overrideName = (_handlerDetails_mcp = handlerDetails.mcp) === null || _handlerDetails_mcp === void 0 ? void 0 : _handlerDetails_mcp.name;
+                            var baseName = overrideName !== null && overrideName !== void 0 ? overrideName : buildMcpToolName(modelSegment, callType, specifier);
+                            var classified = classifyVisibility((_handlerDetails_mcp1 = handlerDetails.mcp) === null || _handlerDetails_mcp1 === void 0 ? void 0 : _handlerDetails_mcp1.visibility);
+                            var isVisible = classified.visibilityKind !== 'never';
+                            candidates.push({
+                                modelType: modelType,
+                                callType: callType,
+                                handlerDetails: handlerDetails,
+                                specifier: specifier,
+                                dispatch: dispatch,
+                                modelSegment: modelSegment,
+                                overrideName: overrideName,
+                                baseName: baseName,
+                                classified: classified,
+                                isVisible: isVisible
+                            });
+                        }
+                    } catch (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                _iterator2.return();
+                            }
+                        } finally{
+                            if (_didIteratorError2) {
+                                throw _iteratorError2;
+                            }
+                        }
+                    }
                 }
             } catch (err) {
                 _didIteratorError1 = true;
@@ -553,19 +922,24 @@ function _unsupported_iterable_to_array$6(o, minLen) {
             }
         }
     }
-    return {
-        tools: tools,
-        neverVisibleTools: neverVisibleTools,
-        skipped: skipped
-    };
+    return candidates;
 }
-function generateToolsForModelCall(context) {
+/**
+ * Counts how many visible, auto-named (no `mcp.name` override) candidates share each preferred name.
+ * Only these participate in clash detection — hidden tools never reach the wire, and overrides are
+ * explicit. A base name with a count over 1 is a clash that the build pass disambiguates.
+ *
+ * @param candidates - The planned candidates from {@link planMcpToolCandidates}.
+ * @returns A map of preferred name to the number of visible auto-named candidates producing it.
+ */ function countVisibleAutoNameClashes(candidates) {
+    var counts = new Map();
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for(var _iterator = Object.entries(context.callDetails.specifiers)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var _step_value = _sliced_to_array$2(_step.value, 2), specifierKey = _step_value[0], handlerDetails = _step_value[1];
-            if (handlerDetails != null) {
-                generateToolForSpecifier(context, specifierKey, handlerDetails);
+        for(var _iterator = candidates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var candidate = _step.value;
+            if (candidate.isVisible && candidate.overrideName == null) {
+                var _counts_get;
+                counts.set(candidate.baseName, ((_counts_get = counts.get(candidate.baseName)) !== null && _counts_get !== void 0 ? _counts_get : 0) + 1);
             }
         }
     } catch (err) {
@@ -582,20 +956,36 @@ function generateToolsForModelCall(context) {
             }
         }
     }
+    return counts;
 }
-function generateToolForSpecifier(context, specifierKey, handlerDetails) {
-    var _ref, _ref1, _resolveRequiredScope;
-    var _handlerDetails_mcp, _handlerDetails_mcp1, _handlerDetails_mcp2, _handlerDetails_mcp3;
-    var modelType = context.modelType, callType = context.callType, callDetails = context.callDetails, options = context.options, manifest = context.manifest, outTools = context.outTools, outNeverVisibleTools = context.outNeverVisibleTools, outSkipped = context.outSkipped;
-    var specifier = callDetails.isSpecifier ? specifierKey : undefined;
-    var dispatch = {
-        call: callType,
-        modelType: modelType,
-        specifier: specifier
-    };
-    var name = (_ref = (_handlerDetails_mcp = handlerDetails.mcp) === null || _handlerDetails_mcp === void 0 ? void 0 : _handlerDetails_mcp.name) !== null && _ref !== void 0 ? _ref : buildMcpToolName(modelType, callType, specifier);
+/**
+ * Second pass: turn one planned {@link McpToolCandidate} into a tool definition, resolving its final
+ * name (disambiguating a clash with the abbreviated call type), generating its schema, and routing it
+ * to the visible or never-visible bucket.
+ *
+ * @param context - The candidate plus the shared generation accumulators.
+ */ function buildToolFromCandidate(context) {
+    var _clashCounts_get, _ref, _resolveRequiredScope;
+    var _handlerDetails_mcp, _handlerDetails_mcp1;
+    var candidate = context.candidate, clashCounts = context.clashCounts, options = context.options, manifest = context.manifest, seenNames = context.seenNames, outTools = context.outTools, outNeverVisibleTools = context.outNeverVisibleTools, outSkipped = context.outSkipped, outWarnings = context.outWarnings;
+    var modelType = candidate.modelType, callType = candidate.callType, handlerDetails = candidate.handlerDetails, specifier = candidate.specifier, dispatch = candidate.dispatch, modelSegment = candidate.modelSegment, overrideName = candidate.overrideName, baseName = candidate.baseName, classified = candidate.classified, isVisible = candidate.isVisible;
+    // A visible auto-named tool whose preferred name is produced by more than one visible tool is
+    // re-derived with the abbreviated call type so both survive on the wire. Overrides and hidden tools
+    // keep their preferred name (overrides are explicit; hidden tools never reach the wire).
+    var needsDisambiguation = isVisible && overrideName == null && ((_clashCounts_get = clashCounts.get(baseName)) !== null && _clashCounts_get !== void 0 ? _clashCounts_get : 0) > 1;
+    var name = needsDisambiguation ? buildDisambiguatedMcpToolName(modelSegment, callType, specifier) : baseName;
+    var nameValidation = validateMcpToolName(name);
+    // A name over the hard cap would make remote clients reject the whole tools/list payload — never advertise it.
+    if (nameValidation.level === 'error') {
+        outSkipped.push({
+            toolName: name,
+            reason: 'name_too_long',
+            dispatch: dispatch
+        });
+        return;
+    }
     var manifestEntry = manifest === null || manifest === void 0 ? void 0 : manifest.get(mcpManifestKey(modelType, callType, specifier));
-    var description = (_ref1 = manifestEntry === null || manifestEntry === void 0 ? void 0 : manifestEntry.description) !== null && _ref1 !== void 0 ? _ref1 : buildDefaultMcpToolDescription(modelType, callType, specifier);
+    var description = (_ref = manifestEntry === null || manifestEntry === void 0 ? void 0 : manifestEntry.description) !== null && _ref !== void 0 ? _ref : buildDefaultMcpToolDescription(modelType, callType, specifier);
     var inputSchema = resolveInputSchema({
         handlerDetails: handlerDetails,
         manifestEntry: manifestEntry,
@@ -607,9 +997,28 @@ function generateToolForSpecifier(context, specifierKey, handlerDetails) {
     if (inputSchema == null) {
         return;
     }
-    var classified = classifyVisibility((_handlerDetails_mcp1 = handlerDetails.mcp) === null || _handlerDetails_mcp1 === void 0 ? void 0 : _handlerDetails_mcp1.visibility);
+    // Cross-check the handler's mapSuccessfulResult against the manifest's mapped-result signal. Only
+    // meaningful when a manifest is supplied (it carries the `.api.ts` annotation outcome).
+    if (manifest != null) {
+        var _handlerDetails_mcp2;
+        var hasMapper = ((_handlerDetails_mcp2 = handlerDetails.mcp) === null || _handlerDetails_mcp2 === void 0 ? void 0 : _handlerDetails_mcp2.mapSuccessfulResult) != null;
+        var manifestMapped = (manifestEntry === null || manifestEntry === void 0 ? void 0 : manifestEntry.mcpResultTypeName) != null;
+        if (hasMapper && !manifestMapped) {
+            outWarnings.push({
+                toolName: name,
+                reason: 'mapper_without_mapped_manifest',
+                dispatch: dispatch
+            });
+        } else if (!hasMapper && manifestMapped) {
+            outWarnings.push({
+                toolName: name,
+                reason: 'mapped_manifest_without_mapper',
+                dispatch: dispatch
+            });
+        }
+    }
     var requiredScope = (_resolveRequiredScope = resolveRequiredScope(callType)) !== null && _resolveRequiredScope !== void 0 ? _resolveRequiredScope : undefined;
-    var effectiveReadOnly = resolveEffectiveReadOnly((_handlerDetails_mcp2 = handlerDetails.mcp) === null || _handlerDetails_mcp2 === void 0 ? void 0 : _handlerDetails_mcp2.readOnly, callType);
+    var effectiveReadOnly = resolveEffectiveReadOnly((_handlerDetails_mcp = handlerDetails.mcp) === null || _handlerDetails_mcp === void 0 ? void 0 : _handlerDetails_mcp.readOnly, callType);
     var filterMetadata;
     if (classified.visibilityKind === 'declarative') {
         filterMetadata = {
@@ -632,6 +1041,21 @@ function generateToolForSpecifier(context, specifierKey, handlerDetails) {
             effectiveReadOnly: effectiveReadOnly
         };
     }
+    // Disambiguation has already separated the common dropped-call-type clash; this is the backstop for
+    // a residual collision it cannot resolve (an `mcp.name` override matching an auto name, or two model
+    // segments coinciding on the same call type) which would otherwise let one tool silently shadow the
+    // other in the per-request name→definition map. Hidden tools never reach the map, so skip the check.
+    if (isVisible) {
+        if (seenNames.has(name)) {
+            outSkipped.push({
+                toolName: name,
+                reason: 'duplicate_name',
+                dispatch: dispatch
+            });
+            return;
+        }
+        seenNames.add(name);
+    }
     var outputSchema = manifestEntry === null || manifestEntry === void 0 ? void 0 : manifestEntry.outputSchema;
     var staticWireEntry = buildStaticWireEntry({
         name: name,
@@ -648,12 +1072,12 @@ function generateToolForSpecifier(context, specifierKey, handlerDetails) {
         dispatch: dispatch,
         filterMetadata: filterMetadata,
         staticWireEntry: staticWireEntry,
-        toolDetailsBuilder: (_handlerDetails_mcp3 = handlerDetails.mcp) === null || _handlerDetails_mcp3 === void 0 ? void 0 : _handlerDetails_mcp3.toolDetails
+        toolDetailsBuilder: (_handlerDetails_mcp1 = handlerDetails.mcp) === null || _handlerDetails_mcp1 === void 0 ? void 0 : _handlerDetails_mcp1.toolDetails
     };
-    if (filterMetadata.visibilityKind === 'never') {
-        outNeverVisibleTools.push(definition);
-    } else {
+    if (isVisible) {
         outTools.push(definition);
+    } else {
+        outNeverVisibleTools.push(definition);
     }
 }
 function resolveInputSchema(context) {
@@ -672,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).
@@ -691,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;
@@ -713,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);
         });
@@ -735,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() {
@@ -915,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([
@@ -1024,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;
@@ -1140,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) {
@@ -1202,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
 /**
@@ -2115,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) {
@@ -2142,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 = [];
@@ -2166,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() {
@@ -2187,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
 /**
@@ -2273,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);
@@ -2452,99 +2876,956 @@ function appendUnknownClaimLines(lines, unknownClaimKeys) {
             if (!_iteratorNormalCompletion && _iterator.return != null) {
                 _iterator.return();
             }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+// MARK: Schemas
+var WHOAMI_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false
+};
+var WHOAMI_OUTPUT_SCHEMA = {
+    type: 'object',
+    required: [
+        'authenticated',
+        'claims',
+        'roles',
+        'claimDetails',
+        'unknownClaimKeys'
+    ],
+    description: 'Caller identity, raw token claims, decoded role set, and per-claim descriptions for every key present on the live token.',
+    properties: {
+        authenticated: {
+            type: 'boolean'
+        },
+        uid: {
+            type: 'string'
+        },
+        email: {
+            type: 'string'
+        },
+        emailVerified: {
+            type: 'boolean'
+        },
+        app: {
+            type: 'string'
+        },
+        claims: {
+            type: 'object',
+            additionalProperties: true
+        },
+        roles: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        claimDetails: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: [
+                    'key',
+                    'description',
+                    'grantedRoles',
+                    'inverse',
+                    'tags'
+                ],
+                properties: {
+                    key: {
+                        type: 'string'
+                    },
+                    interfaceName: {
+                        type: 'string'
+                    },
+                    description: {
+                        type: 'string'
+                    },
+                    grantedRoles: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    inverse: {
+                        type: 'boolean'
+                    },
+                    tags: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        },
+        unknownClaimKeys: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        }
+    }
+};
+
+function _array_like_to_array$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$1(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit$1(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _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 _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+}
+function _ts_generator$3(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+// MARK: Constants
+/**
+ * Reserved tool name for the built-in `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`.
+ *
+ * @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 [
+                        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 WHOAMI_INPUT_SCHEMA = {
-    type: 'object',
-    properties: {},
-    additionalProperties: false
-};
-var WHOAMI_OUTPUT_SCHEMA = {
+var BATCH_EXECUTE_INPUT_SCHEMA = {
     type: 'object',
     required: [
-        'authenticated',
-        'claims',
-        'roles',
-        'claimDetails',
-        'unknownClaimKeys'
+        'uploadPath'
     ],
-    description: 'Caller identity, raw token claims, decoded role set, and per-claim descriptions for every key present on the live token.',
     properties: {
-        authenticated: {
-            type: 'boolean'
+        uploadPath: {
+            type: 'string',
+            minLength: 1,
+            description: 'Storage path of the uploaded operations file (JSON array or NDJSON).'
         },
-        uid: {
-            type: 'string'
+        bucketId: {
+            type: 'string',
+            minLength: 1,
+            description: 'Storage bucket id. Defaults to the app default bucket when omitted.'
         },
-        email: {
-            type: 'string'
+        format: {
+            type: 'string',
+            enum: [
+                'json',
+                'ndjson'
+            ],
+            description: 'File format. "ndjson" (default) = one operation per line; "json" = a top-level array.'
         },
-        emailVerified: {
-            type: 'boolean'
+        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.")
         },
-        app: {
-            type: 'string'
+        stopOnError: {
+            type: 'boolean',
+            description: 'Halt at the first runtime failure (runs sequentially). Defaults to false (best-effort; all operations attempted).'
         },
-        claims: {
-            type: 'object',
-            additionalProperties: true
+        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.'
         },
-        roles: {
-            type: 'array',
-            items: {
-                type: 'string'
-            }
+        successCount: {
+            type: 'integer',
+            description: 'Operations that succeeded.'
         },
-        claimDetails: {
+        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: [
-                    'key',
-                    'description',
-                    'grantedRoles',
-                    'inverse',
-                    'tags'
+                    'index',
+                    'modelType',
+                    'message'
                 ],
                 properties: {
-                    key: {
-                        type: 'string'
+                    index: {
+                        type: 'integer'
                     },
-                    interfaceName: {
+                    modelType: {
                         type: 'string'
                     },
-                    description: {
+                    call: {
                         type: 'string'
                     },
-                    grantedRoles: {
-                        type: 'array',
-                        items: {
-                            type: 'string'
-                        }
-                    },
-                    inverse: {
-                        type: 'boolean'
+                    specifier: {
+                        type: 'string'
                     },
-                    tags: {
-                        type: 'array',
-                        items: {
-                            type: 'string'
-                        }
+                    message: {
+                        type: 'string'
                     }
                 }
             }
         },
-        unknownClaimKeys: {
-            type: 'array',
-            items: {
-                type: 'string'
-            }
+        uploadDeleted: {
+            type: 'boolean',
+            description: 'Whether the uploaded operations file was deleted after the run.'
         }
     }
 };
@@ -2775,12 +4056,13 @@ var McpServerFactoryService_1;
  * 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) {
+    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);
@@ -2795,6 +4077,7 @@ var McpServerFactoryService_1;
         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, [
@@ -2835,6 +4118,16 @@ var McpServerFactoryService_1;
                         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;
@@ -2843,7 +4136,7 @@ var McpServerFactoryService_1;
                             return [
                                 2,
                                 {
-                                    tools: visibleTools.map(function(tool) {
+                                    tools: listedTools.map(function(tool) {
                                         return _this._buildToolListEntry(tool, ctx, scopes);
                                     })
                                 }
@@ -2882,21 +4175,84 @@ var McpServerFactoryService_1;
                         result = {
                             tools: [],
                             neverVisibleTools: [],
-                            skipped: []
+                            skipped: [],
+                            warnings: []
                         };
                     } else {
-                        result = generateMcpToolDefinitions(apiDetails, undefined, manifest);
+                        result = generateMcpToolDefinitions(apiDetails, undefined, {
+                            manifest: manifest,
+                            naming: this._resolveToolNamingOptions()
+                        });
                     }
                     this._cachedTools = result;
                 }
-                if (!this._loggedSkips && result.skipped.length > 0) {
+                if (!this._loggedSkips && (result.skipped.length > 0 || result.warnings.length > 0)) {
                     this._loggedSkips = true;
                     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
                         for(var _iterator = result.skipped[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                             var skip = _step.value;
-                            var errorSuffix = skip.error ? ": ".concat(skip.error.message) : '';
-                            this._logger.warn("Skipped MCP tool ".concat(skip.toolName, " (").concat(skip.reason, ")").concat(errorSuffix));
+                            this._logSkip(skip);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = result.warnings[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var warning = _step1.value;
+                            this._logger.warn(this._describeToolGenerationWarning(warning));
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+                return result;
+            }
+        },
+        {
+            /**
+     * Builds the per-model tool-name segment overrides from the loaded manifest's `models` catalog.
+     *
+     * Sourcing the segments from the manifest (rather than runtime config) keeps the runtime in
+     * agreement with the build-time manifest validation, which reads the same `mcpToolNameSegment`.
+     *
+     * @returns Naming options carrying the segment map, or `undefined` when no model declares one.
+     */ key: "_resolveToolNamingOptions",
+            value: function _resolveToolNamingOptions() {
+                var models = this._cachedManifestModels;
+                var result;
+                if (models != null && models.length > 0) {
+                    var modelSegments = new Map();
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = models[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var model = _step.value;
+                            if (model.mcpToolNameSegment != null && model.mcpToolNameSegment.length > 0) {
+                                modelSegments.set(model.modelType, model.mcpToolNameSegment);
+                            }
                         }
                     } catch (err) {
                         _didIteratorError = true;
@@ -2912,6 +4268,47 @@ var McpServerFactoryService_1;
                             }
                         }
                     }
+                    if (modelSegments.size > 0) {
+                        result = {
+                            modelSegments: modelSegments
+                        };
+                    }
+                }
+                return result;
+            }
+        },
+        {
+            /**
+     * Logs one skipped tool at the appropriate level: name-cap and collision skips are errors (they
+     * would otherwise break or shadow tools on the wire), the rest are warnings.
+     *
+     * @param skip - The skipped-tool report to log.
+     */ key: "_logSkip",
+            value: function _logSkip(skip) {
+                var errorSuffix = skip.error ? ": ".concat(skip.error.message) : '';
+                if (skip.reason === 'name_too_long') {
+                    this._logger.error("Dropped MCP tool ".concat(skip.toolName, " — its name is ").concat(skip.toolName.length, " chars, over the ").concat(MCP_TOOL_NAME_MAX_LENGTH, "-char limit. Shorten the model/specifier, hide it (mcp.visibility: false), or set an mcp.name override."));
+                } else if (skip.reason === 'duplicate_name') {
+                    this._logger.error("Dropped MCP tool ".concat(skip.toolName, " — another visible tool already resolved to this name. Give one an mcp.name override to disambiguate."));
+                } else {
+                    this._logger.warn("Skipped MCP tool ".concat(skip.toolName, " (").concat(skip.reason, ")").concat(errorSuffix));
+                }
+            }
+        },
+        {
+            /**
+     * Renders a human-readable boot-time warning for an MCP-result mapping inconsistency between a
+     * handler's `mapSuccessfulResult` and the build-time manifest.
+     *
+     * @param warning - The tool-generation warning to describe.
+     * @returns The log line to emit at startup.
+     */ key: "_describeToolGenerationWarning",
+            value: function _describeToolGenerationWarning(warning) {
+                var result;
+                if (warning.reason === 'mapper_without_mapped_manifest') {
+                    result = "MCP tool ".concat(warning.toolName, " declares mcp.mapSuccessfulResult but its manifest entry has no mapped result type — annotate the matching '.api.ts' leaf with '@dbxModelApiMcpResult <TypeName>' and regenerate the manifest so the advertised output schema matches the mapped result.");
+                } else {
+                    result = "MCP tool ".concat(warning.toolName, " has a '@dbxModelApiMcpResult' manifest annotation but its handler no longer declares mcp.mapSuccessfulResult — remove the stale annotation and regenerate the manifest, or restore the mapper.");
                 }
                 return result;
             }
@@ -3000,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.
      *
@@ -3424,7 +4907,7 @@ var McpServerFactoryService_1;
             key: "_handleCallModelToolCall",
             value: function _handleCallModelToolCall(definition, args, ctx) {
                 return _async_to_generator$2(function() {
-                    var params, outcome, result, error;
+                    var params, outcome, result, _tmp, error;
                     return _ts_generator$2(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -3438,9 +4921,9 @@ var McpServerFactoryService_1;
                             case 1:
                                 _state.trys.push([
                                     1,
-                                    3,
+                                    4,
                                     ,
-                                    4
+                                    5
                                 ]);
                                 return [
                                     4,
@@ -3448,14 +4931,18 @@ var McpServerFactoryService_1;
                                 ];
                             case 2:
                                 result = _state.sent();
-                                outcome = {
-                                    response: formatMcpToolResponse(result, params, definition.details)
-                                };
+                                _tmp = {};
                                 return [
-                                    3,
-                                    4
+                                    4,
+                                    formatMcpToolResponse(result, params, definition.details)
                                 ];
                             case 3:
+                                outcome = (_tmp.response = _state.sent(), _tmp);
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
                                 error = _state.sent();
                                 outcome = {
                                     response: formatMcpToolErrorResponse(error),
@@ -3463,9 +4950,9 @@ var McpServerFactoryService_1;
                                 };
                                 return [
                                     3,
-                                    4
+                                    5
                                 ];
-                            case 4:
+                            case 5:
                                 return [
                                     2,
                                     outcome
@@ -3487,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) {
@@ -4279,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;
@@ -4288,10 +5781,15 @@ 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;
 exports.MCP_MANIFEST_VERSION = MCP_MANIFEST_VERSION;
 exports.MCP_MODEL_GET_BATCH_SIZE = MCP_MODEL_GET_BATCH_SIZE;
+exports.MCP_TOOL_NAME_MAX_LENGTH = MCP_TOOL_NAME_MAX_LENGTH;
+exports.MCP_TOOL_NAME_WARN_LENGTH = MCP_TOOL_NAME_WARN_LENGTH;
 exports.MODEL_DECODE_DISPATCH_CALL = MODEL_DECODE_DISPATCH_CALL;
 exports.MODEL_DECODE_DISPATCH_MODEL_TYPE = MODEL_DECODE_DISPATCH_MODEL_TYPE;
 exports.MODEL_DECODE_TOOL_NAME = MODEL_DECODE_TOOL_NAME;
@@ -4305,11 +5803,15 @@ exports.MODEL_INFO_TOOL_NAME = MODEL_INFO_TOOL_NAME;
 exports.MODEL_INFO_UNGROUPED_LABEL = MODEL_INFO_UNGROUPED_LABEL;
 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;
@@ -4324,3 +5826,4 @@ exports.mcpModuleMetadata = mcpModuleMetadata;
 exports.noopMcpAnalyticsService = noopMcpAnalyticsService;
 exports.resolveEffectiveReadOnly = resolveEffectiveReadOnly;
 exports.resolveRequiredScope = resolveRequiredScope;
+exports.validateMcpToolName = validateMcpToolName;