agent-embassy 1.8.2 → 1.9.2

package/dist/src/gateway/store.js

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { BridgeError } from "../errors.js";
 import { KeyedMutex } from "../mutex.js";
+import { peerEdgeRef } from "./peer-protocol.js";
 import { deliveryStates, directionId, gatewayActivityActions, gatewayActivityKinds, gatewayProviders, gatewayPublicSnapshotLimits, gatewayRegistrationIngressPrefixes, parseDirection, projectGatewayPublicSnapshot, routeRegistrationModes } from "./types.js";
 const STATE_MARKER = ".agent-embassy-state";
 const STATE_MARKER_CONTENT = "agent-embassy-state-v1\n";
@@ -17,6 +18,7 @@ const DEFAULT_RETAINED_BODY_BYTES = 1 * 1024 * 1024;
 const ALIAS_PATTERN = /^[a-z][a-z0-9_-]{0,31}@[a-z0-9](?:[a-z0-9.-]{0,61}[a-z0-9])?$/;
 const HOST_PATTERN = /^[a-z0-9](?:[a-z0-9.-]{0,61}[a-z0-9])?$/;
 const PRIVATE_TOKEN_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
+const PEER_ROUTE_HANDLE_PATTERN = /^peer:[0-9a-f]{64}$/;
 const SAFE_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
 const MESSAGE_ID_PATTERN = /^msg_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const MESSAGE_SUFFIX_PATTERN = /^[0-9a-f]{8}$/;
@@ -103,6 +105,8 @@ function isRoute(value) {
         isLogicalBinding(value.binding) &&
         typeof value.registrationMode === "string" &&
         REGISTRATION_MODES.has(value.registrationMode) &&
+        (value.binding.provider !== "peer" || value.registrationMode === "federated_peer" ||
+            PEER_ROUTE_HANDLE_PATTERN.test(value.binding.routeHandle)) &&
         typeof value.enabled === "boolean" &&
         (value.busyPolicy === "queue" || value.busyPolicy === "refuse") &&
         isIsoTimestamp(value.registeredAt) &&
@@ -141,11 +145,25 @@ function consentKey(endpoints) {
         .map((endpoint) => [endpoint.provider, endpoint.alias, endpoint.registrationId].join("\0"))
         .join("\0");
 }
+function edgeOwnerHost(endpoints) {
+    return endpoints.map((endpoint) => aliasHost(endpoint.alias)).sort()[0];
+}
+function peerMirrorRegistrationId(host, routeRef) {
+    return `reg_peer_${createHash("sha256").update(`${host}\0${routeRef}`).digest("base64url").slice(0, 32)}`;
+}
 function sameConsent(left, right) {
     if (left === null || right === null)
         return left === right;
     return consentKey(left) === consentKey(right);
 }
+function routeModeMatchesHost(route, localHost) {
+    if (route.registrationMode === "federated_peer") {
+        return localHost !== undefined && route.binding.hostId !== localHost;
+    }
+    return route.binding.hostId === localHost && (route.binding.provider === "claude"
+        ? route.registrationMode === "selected_live_peer"
+        : route.registrationMode === "explicit_opt_in");
+}
 function isConsentEdge(value) {
     if (!isObject(value) ||
         !hasOnlyKeys(value, ["endpoints", "createdAt", "updatedAt", "counters"]) ||
@@ -156,7 +174,7 @@ function isConsentEdge(value) {
     }
     const endpoints = value.endpoints;
     return (compareConsentEndpoints(endpoints[0], endpoints[1]) < 0 &&
-        endpoints[0].provider !== endpoints[1].provider &&
+        endpoints[0].alias !== endpoints[1].alias &&
         isIsoTimestamp(value.createdAt) &&
         isIsoTimestamp(value.updatedAt) &&
         isCounters(value.counters));
@@ -167,7 +185,9 @@ function isPrepared(value) {
         (value.kind === "claude_mailbox" ||
             value.kind === "codex_turn_start" ||
             value.kind === "codex_turn_steer" ||
-            value.kind === "acp_prompt") &&
+            value.kind === "acp_prompt" ||
+            value.kind === "peer_mailbox" ||
+            value.kind === "peer_handoff") &&
         isPositiveInteger(value.bodyBytes) &&
         typeof value.bodySha256 === "string" &&
         SHA256_PATTERN.test(value.bodySha256) &&
@@ -176,13 +196,17 @@ function isPrepared(value) {
         typeof value.sha256 === "string" &&
         SHA256_PATTERN.test(value.sha256));
 }
-function expectedPreparedKind(message) {
+function expectedPreparedKind(message, targetMode) {
+    if (targetMode === "federated_peer")
+        return "peer_handoff";
     const target = parseDirection(message.direction).targetProvider;
     if (target === "claude")
         return "claude_mailbox";
     if (target === "codex") {
         return message.steer === true ? "codex_turn_steer" : "codex_turn_start";
     }
+    if (target === "peer")
+        return "peer_mailbox";
     return "acp_prompt";
 }
 function isAttemptAuthority(value) {
@@ -460,11 +484,15 @@ export function isGatewayPersistedStateV3(value) {
             }
         }
     }
+    const localHosts = new Set(state.routes
+        .filter((route) => route.registrationMode !== "federated_peer")
+        .map((route) => route.binding.hostId));
+    if (localHosts.size > 1)
+        return false;
+    const localHost = [...localHosts][0];
     for (const route of state.routes) {
         if (!route.alias.endsWith(`@${route.binding.hostId}`) ||
-            (route.binding.provider === "claude"
-                ? route.registrationMode !== "selected_live_peer"
-                : route.registrationMode !== "explicit_opt_in")) {
+            !routeModeMatchesHost(route, localHost)) {
             return false;
         }
         const prefix = gatewayRegistrationIngressPrefixes[route.binding.provider];
@@ -479,7 +507,8 @@ export function isGatewayPersistedStateV3(value) {
             right?.binding.registrationId !== rightEndpoint.registrationId ||
             left.binding.provider !== leftEndpoint.provider ||
             right.binding.provider !== rightEndpoint.provider ||
-            left.binding.hostId !== right.binding.hostId) {
+            (left.binding.hostId === right.binding.hostId &&
+                left.binding.provider === right.binding.provider)) {
             return false;
         }
     }
@@ -497,7 +526,8 @@ export function isGatewayPersistedStateV3(value) {
         if (message.sourceRegistrationId !== null) {
             if (source?.binding.registrationId !== message.sourceRegistrationId ||
                 source.binding.provider !== direction.sourceProvider ||
-                (target !== undefined && source.binding.hostId !== target.binding.hostId)) {
+                (target !== undefined && source.binding.hostId === target.binding.hostId &&
+                    source.binding.provider === target.binding.provider)) {
                 return false;
             }
         }
@@ -537,7 +567,7 @@ export function isGatewayPersistedStateV3(value) {
         }
         if ((message.state.phase === "armed" ||
             message.state.phase === "accepted") &&
-            (message.state.prepared.kind !== expectedPreparedKind(message) ||
+            (message.state.prepared.kind !== expectedPreparedKind(message, target?.registrationMode) ||
                 message.state.prepared.bodyBytes !== message.bytes ||
                 message.state.prepared.bodySha256 !==
                     createHash("sha256").update(message.body, "utf8").digest("hex"))) {
@@ -714,6 +744,9 @@ export class GatewayStore {
     async listLogicalRoutes() {
         return this.inspectPrivateRoutes();
     }
+    async inspectPrivateConsentEdges() {
+        return this.read((state) => structuredClone(state.consentEdges));
+    }
     async inspectPrivateRoute(alias) {
         return this.read((state) => {
             const route = state.routes.find((candidate) => candidate.alias === alias);
@@ -725,6 +758,108 @@ export class GatewayStore {
                 };
         });
     }
+    async reconcilePeerCatalog(peerHost, catalog) {
+        return this.mutate((state, now) => {
+            const localHost = this.config.hostId ?? this.config.allowedHosts[0];
+            if (!this.config.allowedHosts.includes(peerHost) || peerHost === localHost ||
+                !catalog.complete || catalog.truncated || catalog.routes.some((route) => route.host !== peerHost) ||
+                catalog.consentEdges.some((edge) => edge.ownerHost !== peerHost)) {
+                throw new BridgeError("INVALID_PEER_CATALOG", "The peer catalog is not an exact complete projection for this configured host.");
+            }
+            const desired = new Map(catalog.routes.map((route) => [route.ref, route]));
+            const existing = state.routes.filter((route) => route.registrationMode === "federated_peer" && route.binding.hostId === peerHost);
+            const settlements = [];
+            for (const route of existing) {
+                const row = desired.get(route.binding.routeHandle);
+                if (row !== undefined && row.provider === route.binding.provider)
+                    continue;
+                settlements.push(...this.terminalizeRegistration(state, route.binding.registrationId, now));
+                this.removeRegistrationMetadata(state, route);
+            }
+            for (const row of catalog.routes) {
+                let route = state.routes.find((candidate) => candidate.registrationMode === "federated_peer" &&
+                    candidate.binding.hostId === peerHost && candidate.binding.routeHandle === row.ref &&
+                    candidate.binding.provider === row.provider);
+                const collision = state.routes.find((candidate) => candidate.alias === row.alias && candidate !== route);
+                if (collision !== undefined)
+                    throw new BridgeError("ROUTE_ALIAS_ALREADY_REGISTERED", "A peer catalog alias conflicts with current local authority.");
+                if (route === undefined) {
+                    if (state.routes.length >= this.config.limits.maxRoutes)
+                        throw new BridgeError("ROUTE_CAPACITY_REACHED", "The bounded logical route inventory is full.", true);
+                    const input = { alias: row.alias, registrationMode: "federated_peer",
+                        binding: { provider: row.provider, hostId: peerHost, routeHandle: row.ref,
+                            registrationId: peerMirrorRegistrationId(peerHost, row.ref) } };
+                    route = routeRecord(input, now);
+                    state.routes.push(route);
+                }
+                else if (route.alias !== row.alias) {
+                    this.renameRegistrationCoordinates(state, route.alias, row.alias, route.binding.registrationId);
+                    route.alias = row.alias;
+                }
+                route.enabled = row.enabled;
+                route.updatedAt = now.toISOString();
+            }
+            const peerOwned = (edge) => edgeOwnerHost(edge.endpoints) === peerHost &&
+                edge.endpoints.some((endpoint) => endpoint.alias.endsWith(`@${peerHost}`));
+            const desiredEdges = [];
+            for (const edge of catalog.consentEdges) {
+                const resolved = edge.endpoints.map((endpoint) => state.routes.find((route) => route.alias === endpoint.alias && route.binding.provider === endpoint.provider &&
+                    (endpoint.host === peerHost ? route.registrationMode === "federated_peer" && route.binding.hostId === peerHost &&
+                        route.binding.routeHandle === endpoint.routeRef : endpoint.host === localHost &&
+                        route.registrationMode !== "federated_peer" && route.binding.hostId === localHost &&
+                        route.binding.registrationId === endpoint.routeRef)));
+                if (resolved[0] === undefined || resolved[1] === undefined || edge.ref !== peerEdgeRef(edge.endpoints))
+                    throw new BridgeError("INVALID_PEER_CATALOG", "A peer consent edge does not match current endpoint authority.");
+                desiredEdges.push(canonicalConsentEndpoints(resolved[0], resolved[1]));
+            }
+            const removedEdges = state.consentEdges.filter((edge) => peerOwned(edge) &&
+                !desiredEdges.some((candidate) => sameConsent(edge.endpoints, candidate)));
+            for (const edge of removedEdges)
+                settlements.push(...this.terminalizeConsentEdge(state, edge, now));
+            state.consentEdges = state.consentEdges.filter((edge) => !removedEdges.includes(edge));
+            for (const endpoints of desiredEdges) {
+                if (state.consentEdges.some((edge) => sameConsent(edge.endpoints, endpoints)))
+                    continue;
+                if (state.consentEdges.length >= this.config.limits.maxConsentEdges)
+                    throw new BridgeError("CONSENT_EDGE_CAPACITY_REACHED", "The bounded consent-edge inventory is full.", true);
+                state.consentEdges.push({ endpoints, createdAt: now.toISOString(), updatedAt: now.toISOString(), counters: emptyCounters() });
+            }
+            return { settlements, routes: state.routes.filter((route) => route.registrationMode === "federated_peer" &&
+                    route.binding.hostId === peerHost).map((route) => ({ alias: route.alias, binding: { ...route.binding },
+                    registrationMode: route.registrationMode, enabled: route.enabled })) };
+        });
+    }
+    async enqueuePeerHandoff(peerHost, handoff) {
+        return this.mutate((state, now) => {
+            const localHost = this.config.hostId ?? this.config.allowedHosts[0];
+            if (!this.config.allowedHosts.includes(peerHost) || peerHost === localHost || handoff.source.host !== peerHost ||
+                handoff.target.host !== localHost || handoff.edgeOwnerHost !== [peerHost, localHost].sort()[0] ||
+                handoff.edgeRef !== peerEdgeRef([handoff.source, handoff.target]))
+                throw new BridgeError("INVALID_PEER_HANDOFF", "The peer handoff does not match this configured direct link.");
+            const source = state.routes.find((route) => route.registrationMode === "federated_peer" && route.binding.hostId === peerHost &&
+                route.alias === handoff.source.alias && route.binding.provider === handoff.source.provider && route.binding.routeHandle === handoff.source.routeRef);
+            const target = state.routes.find((route) => route.registrationMode !== "federated_peer" && route.binding.hostId === localHost &&
+                route.alias === handoff.target.alias && route.binding.provider === handoff.target.provider &&
+                route.binding.registrationId === handoff.target.routeRef && route.enabled);
+            if (source === undefined || target === undefined)
+                throw new BridgeError("ROUTE_UNREGISTERED", "The peer handoff endpoint is no longer current.");
+            const endpoints = canonicalConsentEndpoints(source, target);
+            let edge = state.consentEdges.find((candidate) => sameConsent(candidate.endpoints, endpoints));
+            if (edge === undefined && handoff.edgeOwnerHost === peerHost) {
+                if (state.consentEdges.length >= this.config.limits.maxConsentEdges)
+                    throw new BridgeError("CONSENT_EDGE_CAPACITY_REACHED", "The bounded consent-edge inventory is full.", true);
+                edge = { endpoints, createdAt: now.toISOString(), updatedAt: now.toISOString(), counters: emptyCounters() };
+                state.consentEdges.push(edge);
+            }
+            if (edge === undefined)
+                throw new BridgeError("SENDER_NOT_PAIRED", "The peer handoff lacks current exact consent.");
+            return this.enqueueResolved(state, now, { body: handoff.body, dedupeKey: `${peerHost}:${handoff.originMessageId}`,
+                deadlineAt: handoff.deadlineAt, ...(handoff.conversationCorrelation === undefined ? {} :
+                    { conversationIdSuffix: handoff.conversationCorrelation }), ...(handoff.steer === true ? { steer: true } : {}) }, { sourceAlias: source.alias, targetAlias: target.alias, direction: directionId(source.binding.provider, target.binding.provider),
+                sourceRegistrationId: source.binding.registrationId, targetRegistrationId: target.binding.registrationId,
+                consentEdge: edge.endpoints, pair: true, exposeDeliveryToken: false });
+        });
+    }
     async registerRoute(input) {
         await this.mutate((state, now) => {
             this.validateRouteInput(input);
@@ -909,23 +1044,7 @@ export class GatewayStore {
             if (index < 0)
                 return { settlements: [], unreferencedAliases: [] };
             const edge = state.consentEdges[index];
-            const settlements = [];
-            for (const message of state.messages) {
-                if (message.state.phase === "terminal" ||
-                    !sameConsent(message.consentEdge, edge.endpoints)) {
-                    continue;
-                }
-                const outcome = message.state.phase === "armed"
-                    ? "ambiguous"
-                    : message.state.phase === "accepted"
-                        ? message.state.lossOutcome
-                        : "cancelled";
-                settlements.push(this.finishMessage(state, message, outcome, now, outcome === "ambiguous"
-                    ? "DISPATCH_OUTCOME_AMBIGUOUS"
-                    : outcome === "unconfirmed"
-                        ? "DELIVERY_UNCONFIRMED"
-                        : "SENDER_NOT_PAIRED"));
-            }
+            const settlements = this.terminalizeConsentEdge(state, edge, now);
             state.consentEdges.splice(index, 1);
             return {
                 settlements,
@@ -973,9 +1092,11 @@ export class GatewayStore {
                 target.binding.registrationId !== input.expectedTargetRegistrationId) {
                 throw new BridgeError("ROUTE_UNREGISTERED", "The native ingress target registration is no longer current.");
             }
+            const nativeSourceHost = target.registrationMode === "federated_peer"
+                ? (this.config.hostId ?? this.config.allowedHosts[0]) : target.binding.hostId;
             if (input.source.binding.provider !== "claude" ||
-                input.source.binding.hostId !== target.binding.hostId ||
-                input.source.alias.endsWith(`@${target.binding.hostId}`) === false) {
+                input.source.binding.hostId !== nativeSourceHost ||
+                input.source.alias.endsWith(`@${nativeSourceHost}`) === false) {
                 throw new BridgeError("INVALID_NATIVE_PEER", "The native Claude sender does not match the target host.");
             }
             const selected = state.routes.find((route) => route.alias === input.source.alias &&
@@ -985,7 +1106,7 @@ export class GatewayStore {
             const edge = selected === undefined
                 ? undefined
                 : state.consentEdges.find((candidate) => sameConsent(candidate.endpoints, canonicalConsentEndpoints(selected, target)));
-            if (this.config.inboundMode === "paired" && edge === undefined) {
+            if ((this.config.inboundMode === "paired" || target.registrationMode === "federated_peer") && edge === undefined) {
                 this.recordRejection(state, {
                     sourceAlias: input.source.alias, targetAlias: target.alias,
                     direction: directionId("claude", target.binding.provider),
@@ -1137,15 +1258,15 @@ export class GatewayStore {
             const bodySha256 = createHash("sha256")
                 .update(message.body ?? "", "utf8")
                 .digest("hex");
+            const target = state.routes.find((route) => route.alias === message.targetAlias &&
+                route.binding.registrationId === message.targetRegistrationId &&
+                route.enabled);
             if (!isPrepared(input.prepared) ||
-                input.prepared.kind !== expectedPreparedKind(message) ||
+                input.prepared.kind !== expectedPreparedKind(message, target?.registrationMode) ||
                 input.prepared.bodyBytes !== message.bytes ||
                 input.prepared.bodySha256 !== bodySha256) {
                 throw new BridgeError("INVALID_PREPARED_WRITE_EVIDENCE", "The prepared payload evidence does not match the admitted message.");
             }
-            const target = state.routes.find((route) => route.alias === message.targetAlias &&
-                route.binding.registrationId === message.targetRegistrationId &&
-                route.enabled);
             if (input.sourceRegistrationId !== message.sourceRegistrationId ||
                 input.targetRegistrationId !== message.targetRegistrationId ||
                 (message.transientTarget !== true && target === undefined)) {
@@ -1228,8 +1349,8 @@ export class GatewayStore {
             if ((message.state.phase === "armed" &&
                 (input.state === "expired" ||
                     (input.state === "unconfirmed" &&
-                        (input.safeErrorCode !== "ACP_OUTCOME_COARSE" ||
-                            message.state.prepared.kind !== "acp_prompt")))) ||
+                        !((input.safeErrorCode === "ACP_OUTCOME_COARSE" && message.state.prepared.kind === "acp_prompt") ||
+                            (input.safeErrorCode === "PEER_HANDOFF_ACCEPTANCE_UNCONFIRMED" && message.state.prepared.kind === "peer_handoff"))))) ||
                 (message.state.phase === "accepted" &&
                     (input.state === "expired" ||
                         (input.state === "unconfirmed" &&
@@ -1314,6 +1435,7 @@ export class GatewayStore {
                         ? {}
                         : { oldestQueuedAt: queued[0].enqueuedAt }),
                     counters: { ...route.counters },
+                    mutable: route.registrationMode !== "federated_peer",
                 };
             });
             const consentEdges = state.consentEdges.map((edge) => ({
@@ -1325,7 +1447,8 @@ export class GatewayStore {
                         alias: edge.endpoints[1].alias, provider: edge.endpoints[1].provider,
                     },
                 ],
-                host: aliasHost(edge.endpoints[0].alias), counters: { ...edge.counters },
+                host: edgeOwnerHost(edge.endpoints), counters: { ...edge.counters },
+                mutable: edgeOwnerHost(edge.endpoints) === (this.config.hostId ?? this.config.allowedHosts[0]),
             }));
             const currentEvents = state.messages.map((message) => this.projectMessageEvent(message));
             const legacyEvents = state.activity
@@ -1422,15 +1545,16 @@ export class GatewayStore {
         };
     }
     validateRouteInput(input) {
+        const localHost = this.config.hostId ?? this.config.allowedHosts[0];
         if (!isObject(input) ||
             !ALIAS_PATTERN.test(input.alias) ||
             !isLogicalBinding(input.binding) ||
             !REGISTRATION_MODES.has(input.registrationMode) ||
+            (input.binding.provider === "peer" && input.registrationMode !== "federated_peer" &&
+                !PEER_ROUTE_HANDLE_PATTERN.test(input.binding.routeHandle)) ||
             !input.alias.endsWith(`@${input.binding.hostId}`) ||
             !this.config.allowedHosts.includes(input.binding.hostId) ||
-            (input.binding.provider === "claude"
-                ? input.registrationMode !== "selected_live_peer"
-                : input.registrationMode !== "explicit_opt_in")) {
+            !routeModeMatchesHost(input, localHost)) {
             throw new BridgeError("INVALID_ROUTE_BINDING", "The logical route binding is invalid for this gateway.");
         }
         const prefix = gatewayRegistrationIngressPrefixes[input.binding.provider];
@@ -1469,10 +1593,10 @@ export class GatewayStore {
         }
         if (left === undefined ||
             right === undefined ||
-            left.binding.provider === right.binding.provider ||
-            left.binding.hostId !== right.binding.hostId) {
+            (left.binding.provider === right.binding.provider &&
+                left.binding.hostId === right.binding.hostId)) {
             if (required) {
-                throw new BridgeError("INVALID_CONSENT_EDGE", "Consent requires exact same-host routes from distinct providers.");
+                throw new BridgeError("INVALID_CONSENT_EDGE", "Consent requires distinct providers or distinct configured hosts.");
             }
             return undefined;
         }
@@ -1633,6 +1757,16 @@ export class GatewayStore {
                 : { supersededSettlement }),
         };
     }
+    terminalizeConsentEdge(state, edge, now) {
+        return state.messages.filter((message) => message.state.phase !== "terminal" &&
+            sameConsent(message.consentEdge, edge.endpoints)).map((message) => {
+            const outcome = message.state.phase === "armed" ? "ambiguous" :
+                message.state.phase === "accepted" ? message.state.lossOutcome : "cancelled";
+            return this.finishMessage(state, message, outcome, now, outcome === "ambiguous"
+                ? "DISPATCH_OUTCOME_AMBIGUOUS" : outcome === "unconfirmed"
+                ? "DELIVERY_UNCONFIRMED" : "SENDER_NOT_PAIRED");
+        });
+    }
     allocateDeliveryToken(state) {
         for (let attempt = 0; attempt < 8; attempt += 1) {
             const token = `dlv_${createHash("sha256")
@@ -1709,11 +1843,16 @@ export class GatewayStore {
                     : { safeErrorCode: message.state.safeErrorCode }),
             };
         }
+        const handedOff = outcome === "delivered" &&
+            (message.state.phase === "armed" || message.state.phase === "accepted") &&
+            message.state.prepared.kind === "peer_handoff";
         if (message.state.phase === "queued") {
             state.accounting.queuedBytes -= message.bytes;
         }
         message.state = terminalState(outcome, now, message.enqueuedAt, safeErrorCode);
         this.touchMessage(state, message);
+        if (handedOff)
+            delete message.body;
         state.accounting[outcome] += 1;
         const target = state.routes.find((route) => route.binding.registrationId === message.targetRegistrationId);
         if (target !== undefined)
@@ -1911,7 +2050,8 @@ export class GatewayStore {
     }
     assertConfiguredBounds(state) {
         const active = state.messages.filter((message) => message.state.phase !== "terminal");
-        if (state.routes.some((route) => !this.config.allowedHosts.includes(route.binding.hostId)) ||
+        if (state.routes.some((route) => !this.config.allowedHosts.includes(route.binding.hostId) ||
+            !routeModeMatchesHost(route, this.config.hostId ?? this.config.allowedHosts[0])) ||
             state.routes.length > this.config.limits.maxRoutes ||
             state.consentEdges.length > this.config.limits.maxConsentEdges ||
             active.length > this.config.limits.maxQueueMessages ||