@desplega.ai/agent-swarm 1.166.0 → 1.167.0

package/dist/{http-3h21z9md.js → http-jsmtag08.js}

@@ -23,11 +23,11 @@ import {
 } from "./cli-2pdaysab.js";
 import {
   reasoningCapability
-} from "./cli-ttbsse3f.js";
+} from "./cli-tmhsxhb8.js";
 import {
   ensureAgentFsCredentialsForAgent,
   inviteEmailToSharedOrg
-} from "./cli-gt8azyet.js";
+} from "./cli-c2tpw9ck.js";
 import {
   DEFAULT_CONNECTOR_CODE_LABEL,
   checkHeartbeatChecklist,
@@ -35,10 +35,10 @@ import {
   exchangeConnectorCode,
   runHeartbeatSweep,
   stopHeartbeat
-} from "./cli-66zh26sp.js";
+} from "./cli-qzmzwegq.js";
 import {
   Anthropic
-} from "./cli-zy7vwsne.js";
+} from "./cli-5qkcdv8c.js";
 import {
   AGENT_MAX_TASKS_CONFIG_KEY,
   ALL_CAPABILITIES,
@@ -335,7 +335,7 @@ import {
   workflowModelErrors,
   workflowSaveWarnings,
   writeUnhandledError
-} from "./cli-df56tqdw.js";
+} from "./cli-wydz3feg.js";
 import"./cli-xvc3q9br.js";
 import {
   AMP_ESTIMATE_MODELS,
@@ -350,16 +350,16 @@ import {
 import {
   isMultiRuntimeEnabled
 } from "./cli-re8z5p8p.js";
-import"./cli-0nhdwxd5.js";
+import"./cli-tx2zvn23.js";
 import {
   deleteModelCatalogOverlay,
   loadModelsCatalog,
   requestModelCatalogRefresh,
   upsertModelCatalogOverlay
-} from "./cli-rggdq8wq.js";
+} from "./cli-p8rt8spp.js";
 import {
   normalizeModelKey
-} from "./cli-ysnyhws9.js";
+} from "./cli-v1pwxreq.js";
 import {
   ConnectionAuthInputSchema,
   MAX_SCRIPT_WALL_CLOCK_MS,
@@ -436,19 +436,12 @@ import {
   upsertMcpOAuthToken,
   upsertScriptConnection,
   validateDefinition
-} from "./cli-jvj6a0cv.js";
+} from "./cli-577bxkf6.js";
 import"./cli-epan13p1.js";
 import {
   getApiKey
 } from "./cli-f14fvzag.js";
-import {
-  detachedProcessGroup,
-  forceTerminateProcessGroup,
-  registerProcessGroup,
-  signalProcessGroup,
-  terminateProcessGroup
-} from "./cli-zt3w1cn1.js";
-import"./cli-f2n17zhp.js";
+import"./cli-7mhy3ths.js";
 import {
   CLIENT_ID,
   MAX_CODEX_OAUTH_SLOT,
@@ -459,11 +452,24 @@ import {
   getAccountId,
   getValidCodexOAuth,
   loadAllCodexOAuthSlots
-} from "./cli-feh3dkah.js";
-import"./cli-3dpj7atn.js";
-import"./cli-2x0e561b.js";
-import"./cli-pkke6geq.js";
+} from "./cli-v1w7pbd8.js";
+import {
+  detachedProcessGroup,
+  forceTerminateProcessGroup,
+  registerProcessGroup,
+  signalProcessGroup,
+  terminateProcessGroup
+} from "./cli-zt3w1cn1.js";
+import"./cli-km4x66j0.js";
 import"./cli-rb9m6rpe.js";
+import"./cli-2x0e561b.js";
+import {
+  buildAuthorizationUrl,
+  exchangeAuthorizationCode,
+  forceRefreshAuthorizationOrThrow,
+  forceRefreshTokenOrThrow,
+  oauthAppRowToProviderConfig
+} from "./cli-kw0jcfje.js";
 import {
   AgentFsProvider,
   FilesError,
@@ -471,13 +477,6 @@ import {
   getFileStorageProvider,
   normalizeFilesError
 } from "./cli-mzfth0bp.js";
-import {
-  buildAuthorizationUrl,
-  exchangeAuthorizationCode,
-  forceRefreshAuthorizationOrThrow,
-  forceRefreshTokenOrThrow,
-  oauthAppRowToProviderConfig
-} from "./cli-j2jbr8af.js";
 import"./cli-fad8m16k.js";
 import"./cli-bsakbbkm.js";
 import"./cli-zxg80zs9.js";
@@ -496,33 +495,34 @@ import {
   recordDbRetentionStatement,
   recordDbRetentionSweep,
   recordSessionCost,
+  require_content_type,
   startSlackApp,
   startSpan,
   stopSlackApp,
   withRemoteContext,
   withSpan,
   withSpanContext
-} from "./cli-ecknp7p1.js";
+} from "./cli-c8r99akr.js";
 import"./cli-q51yprfq.js";
 import"./cli-3er6gcsn.js";
 import"./cli-yatxqynm.js";
 import {
   bedrockProviderModule
-} from "./cli-ng97fjq7.js";
+} from "./cli-cmxkbzzs.js";
 import"./cli-yn0a417a.js";
 import"./cli-cgj4hc12.js";
 import"./cli-txgcknmy.js";
 import"./cli-6map995v.js";
-import"./cli-8kt0bmgx.js";
+import"./cli-xf713zz0.js";
 import"./cli-y2apkfe2.js";
 import"./cli-7kyk9jr3.js";
 import {
   setBedrockProviderModule
-} from "./cli-b0f70z24.js";
-import"./cli-nexwh8zg.js";
+} from "./cli-mn8qkd8v.js";
+import"./cli-g7k7zbcz.js";
 import"./cli-btbzvq95.js";
 import"./cli-1m2e086m.js";
-import"./cli-bzr0ftht.js";
+import"./cli-wnb9b2g3.js";
 import"./cli-bd957dgb.js";
 import {
   import_websocket,
@@ -532,7 +532,7 @@ import"./cli-pzxba7gw.js";
 import {
   getUserGrant,
   init_rbac_roles
-} from "./cli-8kgvmkak.js";
+} from "./cli-ypgba1a8.js";
 import {
   LEGACY_RULES,
   can,
@@ -925,7 +925,8 @@ import {
   upsertSwarmConfig,
   validateConfigValue,
   withFavoriteFlags
-} from "./cli-yshaazs1.js";
+} from "./cli-mkdsy1nq.js";
+import"./cli-3qhyh31j.js";
 import {
   ActiveSessionSchema,
   AgentAcpStatusSchema,
@@ -1053,12 +1054,11 @@ import {
   isTerminalTaskStatus,
   splitLegacyModelAlias
 } from "./cli-xvdgasgy.js";
-import"./cli-3qhyh31j.js";
 import {
   IDENTITY_FIELD_BUDGETS,
   IdentityFieldBudgetError,
   init_identity_field_budget
-} from "./cli-jhm6hzjn.js";
+} from "./cli-mxvnnv5q.js";
 import {
   init_steering_enabled,
   isSteeringEnabled
@@ -1068,21 +1068,6 @@ import {
   getSlackConfiguration,
   init_config
 } from "./cli-dmtrxqhg.js";
-import"./cli-tadfgd0t.js";
-import {
-  MODEL_SCOPED_WINDOWS,
-  activeModelBlocks,
-  init_model_rate_limit_windows
-} from "./cli-ywybs5as.js";
-import {
-  MAX_PROFILE_FILE_LENGTH,
-  agentFsFileRoute,
-  getAppUrl,
-  getConfiguredAppUrls,
-  getMcpBaseUrl,
-  getPublicMcpBaseUrl,
-  init_constants
-} from "./cli-gd4favx9.js";
 import"./cli-agamgm0p.js";
 import {
   getAllTemplateDefinitions,
@@ -1099,7 +1084,26 @@ import {
   init_subscription_plans,
   isSubscriptionPlanId
 } from "./cli-1a2j50m0.js";
+import"./cli-tadfgd0t.js";
+import {
+  MODEL_SCOPED_WINDOWS,
+  activeModelBlocks,
+  init_model_rate_limit_windows
+} from "./cli-ywybs5as.js";
 import"./cli-f9w1semm.js";
+import {
+  getOpenRouterAttributionHeaders,
+  init_openrouter_base_url
+} from "./cli-a35hzdve.js";
+import {
+  MAX_PROFILE_FILE_LENGTH,
+  agentFsFileRoute,
+  getAppUrl,
+  getConfiguredAppUrls,
+  getMcpBaseUrl,
+  getPublicMcpBaseUrl,
+  init_constants
+} from "./cli-gd4favx9.js";
 import {
   init_env_flag,
   isEnvFlagEnabled,
@@ -1108,7 +1112,7 @@ import {
 import {
   init_src,
   isAlias
-} from "./cli-zsh093hk.js";
+} from "./cli-014vns2y.js";
 import {
   exports_zod,
   init_zod
@@ -1125,7 +1129,7 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-4r1sjfc4.js";
+} from "./cli-ymmc1zxg.js";
 import {
   init_event_bus,
   workflowEventBus
@@ -12959,6 +12963,85 @@ var getRequestListener = (fetchCallback, options = {}) => {
   };
 };
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/mediaType.js
+var import_content_type = __toESM(require_content_type(), 1);
+function mediaTypeEssence(header2) {
+  if (!header2) {
+    return;
+  }
+  try {
+    return import_content_type.default.parse(header2).type;
+  } catch {
+    const essence = (header2.split(";", 1)[0] ?? "").trim().toLowerCase();
+    if (essence === "" || header2.slice(essence.length).includes(",")) {
+      return;
+    }
+    return essence;
+  }
+}
+function isJsonContentType(header2) {
+  if (header2 === "application/json") {
+    return true;
+  }
+  return mediaTypeEssence(header2) === "application/json";
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/requestBody.js
+var DEFAULT_MAX_REQUEST_BODY_SIZE = 4 * 1024 * 1024;
+var MAX_BATCH_SIZE2 = 100;
+function requestBodyTooLargeMessage(maxBytes) {
+  return `Payload Too Large: Request body must not exceed ${maxBytes} bytes`;
+}
+function resolveMaxRequestBodySize(value) {
+  if (value === undefined) {
+    return DEFAULT_MAX_REQUEST_BODY_SIZE;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`maxRequestBodySize must be a positive number of bytes, got ${String(value)}`);
+  }
+  return value;
+}
+async function readRequestBody(request, maxBytes = DEFAULT_MAX_REQUEST_BODY_SIZE) {
+  if (Number(request.headers.get("content-length")) > maxBytes) {
+    return { tooLarge: true };
+  }
+  if (request.body === null) {
+    return { tooLarge: false, text: "" };
+  }
+  const reader = request.body.getReader();
+  const decoder = new TextDecoder;
+  let received = 0;
+  let text = "";
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      received += value.byteLength;
+      if (received > maxBytes) {
+        return { tooLarge: true };
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return { tooLarge: false, text: text + decoder.decode() };
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/sseKeepAlive.js
+var DEFAULT_SSE_KEEP_ALIVE_MS = 15000;
+var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
+function armSseKeepAlive(intervalMs, onTick) {
+  if (!Number.isFinite(intervalMs) || intervalMs < 1) {
+    return;
+  }
+  const timer = setInterval(onTick, Math.min(intervalMs, MAX_TIMER_DELAY_MS));
+  timer.unref?.();
+  return timer;
+}
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
 class WebStandardStreamableHTTPServerTransport {
   constructor(options = {}) {
@@ -12966,10 +13049,12 @@ class WebStandardStreamableHTTPServerTransport {
     this._hasHandledRequest = false;
     this._streamMapping = new Map;
     this._requestToStreamMapping = new Map;
+    this._resumableStreams = new Set;
     this._requestResponseMap = new Map;
     this._initialized = false;
     this._enableJsonResponse = false;
     this._standaloneSseStreamId = "_GET_stream";
+    this._closed = false;
     this.sessionIdGenerator = options.sessionIdGenerator;
     this._enableJsonResponse = options.enableJsonResponse ?? false;
     this._eventStore = options.eventStore;
@@ -12979,6 +13064,23 @@ class WebStandardStreamableHTTPServerTransport {
     this._allowedOrigins = options.allowedOrigins;
     this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
     this._retryInterval = options.retryInterval;
+    this._keepAliveMs = options.keepAliveMs ?? DEFAULT_SSE_KEEP_ALIVE_MS;
+    this._maxRequestBodySize = resolveMaxRequestBodySize(options.maxRequestBodySize);
+  }
+  startKeepAlive(controller, encoder) {
+    if (this._closed)
+      return;
+    const timer = armSseKeepAlive(this._keepAliveMs, () => {
+      try {
+        controller.enqueue(encoder.encode(`: keepalive
+
+`));
+      } catch {
+        if (timer !== undefined)
+          clearInterval(timer);
+      }
+    });
+    return timer;
   }
   async start() {
     if (this._started) {
@@ -13026,6 +13128,9 @@ class WebStandardStreamableHTTPServerTransport {
     return;
   }
   async handleRequest(req, options) {
+    if (this._closed) {
+      return this.createJsonErrorResponse(404, -32001, "Session not found");
+    }
     if (!this.sessionIdGenerator && this._hasHandledRequest) {
       throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
     }
@@ -13065,6 +13170,7 @@ data:
 `;
     }
     controller.enqueue(encoder.encode(primingEvent));
+    this._resumableStreams.add(streamId);
   }
   async handleGetRequest(req) {
     const acceptHeader = req.headers.get("accept");
@@ -13092,18 +13198,25 @@ data:
     }
     const encoder = new TextEncoder;
     let streamController;
+    let keepAliveTimer = undefined;
     const readable = new ReadableStream({
       start: (controller) => {
         streamController = controller;
       },
       cancel: () => {
-        this._streamMapping.delete(this._standaloneSseStreamId);
+        if (keepAliveTimer !== undefined) {
+          clearInterval(keepAliveTimer);
+        }
+        if (this._streamMapping.get(this._standaloneSseStreamId)?.controller === streamController) {
+          this._streamMapping.delete(this._standaloneSseStreamId);
+        }
       }
     });
     const headers2 = {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache, no-transform",
-      Connection: "keep-alive"
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
     };
     if (this.sessionId !== undefined) {
       headers2["mcp-session-id"] = this.sessionId;
@@ -13112,12 +13225,16 @@ data:
       controller: streamController,
       encoder,
       cleanup: () => {
+        if (keepAliveTimer !== undefined) {
+          clearInterval(keepAliveTimer);
+        }
         this._streamMapping.delete(this._standaloneSseStreamId);
         try {
           streamController.close();
         } catch {}
       }
     });
+    keepAliveTimer = this.startKeepAlive(streamController, encoder);
     return new Response(readable, { headers: headers2 });
   }
   async replayEvents(lastEventId) {
@@ -13141,20 +13258,33 @@ data:
       const headers2 = {
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache, no-transform",
-        Connection: "keep-alive"
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no"
       };
       if (this.sessionId !== undefined) {
         headers2["mcp-session-id"] = this.sessionId;
       }
       const encoder = new TextEncoder;
       let streamController;
+      let keepAliveTimer = undefined;
+      let replayedStreamId = undefined;
+      let cancelled = false;
       const readable = new ReadableStream({
         start: (controller) => {
           streamController = controller;
         },
-        cancel: () => {}
+        cancel: () => {
+          cancelled = true;
+          if (keepAliveTimer !== undefined) {
+            clearInterval(keepAliveTimer);
+          }
+          if (replayedStreamId !== undefined && this._streamMapping.get(replayedStreamId)?.controller === streamController) {
+            this._streamMapping.delete(replayedStreamId);
+          }
+        }
       });
-      const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
+      const replayedEventIds = new Set;
+      replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
         send: async (eventId, message) => {
           const success = this.writeSSEEvent(streamController, encoder, message, eventId);
           if (!success) {
@@ -13162,19 +13292,34 @@ data:
             try {
               streamController.close();
             } catch {}
+          } else {
+            replayedEventIds.add(eventId);
           }
         }
       });
+      if (this._closed || cancelled) {
+        try {
+          streamController.close();
+        } catch {}
+        return this.createJsonErrorResponse(404, -32001, "Session not found");
+      }
+      this._streamMapping.get(replayedStreamId)?.cleanup();
       this._streamMapping.set(replayedStreamId, {
         controller: streamController,
         encoder,
+        replayedEventIds,
         cleanup: () => {
+          if (keepAliveTimer !== undefined) {
+            clearInterval(keepAliveTimer);
+          }
           this._streamMapping.delete(replayedStreamId);
           try {
             streamController.close();
           } catch {}
         }
       });
+      this._resumableStreams.add(replayedStreamId);
+      keepAliveTimer = this.startKeepAlive(streamController, encoder);
       return new Response(readable, { headers: headers2 });
     } catch (error) {
       this.onerror?.(error);
@@ -13224,7 +13369,7 @@ data:
         return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept both application/json and text/event-stream");
       }
       const ct = req.headers.get("content-type");
-      if (!ct || !ct.includes("application/json")) {
+      if (!isJsonContentType(ct)) {
         this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
         return this.createJsonErrorResponse(415, -32000, "Unsupported Media Type: Content-Type must be application/json");
       }
@@ -13237,12 +13382,22 @@ data:
         rawMessage = options.parsedBody;
       } else {
         try {
-          rawMessage = await req.json();
+          const body = await readRequestBody(req, this._maxRequestBodySize);
+          if (body.tooLarge) {
+            const message = requestBodyTooLargeMessage(this._maxRequestBodySize);
+            this.onerror?.(new Error(message));
+            return this.createJsonErrorResponse(413, -32000, message);
+          }
+          rawMessage = JSON.parse(body.text);
         } catch {
           this.onerror?.(new Error("Parse error: Invalid JSON"));
           return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
         }
       }
+      if (Array.isArray(rawMessage) && rawMessage.length > MAX_BATCH_SIZE2) {
+        this.onerror?.(new Error(`Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE2} messages`));
+        return this.createJsonErrorResponse(400, -32600, `Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE2} messages`);
+      }
       let messages;
       try {
         if (Array.isArray(rawMessage)) {
@@ -13254,6 +13409,9 @@ data:
         this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
         return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
       }
+      if (this._closed) {
+        return this.createJsonErrorResponse(404, -32001, "Session not found");
+      }
       const isInitializationRequest = messages.some(isInitializeRequest);
       if (isInitializationRequest) {
         if (this._initialized && this.sessionId !== undefined) {
@@ -13280,6 +13438,9 @@ data:
           return protocolError2;
         }
       }
+      if (this._closed) {
+        return this.createJsonErrorResponse(404, -32001, "Session not found");
+      }
       const hasRequests = messages.some(isJSONRPCRequest);
       if (!hasRequests) {
         for (const message of messages) {
@@ -13310,18 +13471,25 @@ data:
       }
       const encoder = new TextEncoder;
       let streamController;
+      let keepAliveTimer = undefined;
       const readable = new ReadableStream({
         start: (controller) => {
           streamController = controller;
         },
         cancel: () => {
-          this._streamMapping.delete(streamId);
+          if (keepAliveTimer !== undefined) {
+            clearInterval(keepAliveTimer);
+          }
+          if (this._streamMapping.get(streamId)?.controller === streamController) {
+            this._streamMapping.delete(streamId);
+          }
         }
       });
       const headers2 = {
         "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no"
       };
       if (this.sessionId !== undefined) {
         headers2["mcp-session-id"] = this.sessionId;
@@ -13332,6 +13500,9 @@ data:
             controller: streamController,
             encoder,
             cleanup: () => {
+              if (keepAliveTimer !== undefined) {
+                clearInterval(keepAliveTimer);
+              }
               this._streamMapping.delete(streamId);
               try {
                 streamController.close();
@@ -13341,19 +13512,33 @@ data:
           this._requestToStreamMapping.set(message.id, streamId);
         }
       }
-      await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
-      for (const message of messages) {
-        let closeSSEStream;
-        let closeStandaloneSSEStream;
-        if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
-          closeSSEStream = () => {
-            this.closeSSEStream(message.id);
-          };
-          closeStandaloneSSEStream = () => {
-            this.closeStandaloneSSEStream();
-          };
+      try {
+        await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
+        for (const message of messages) {
+          let closeSSEStream;
+          let closeStandaloneSSEStream;
+          if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
+            closeSSEStream = () => {
+              this.closeSSEStream(message.id);
+            };
+            closeStandaloneSSEStream = () => {
+              this.closeStandaloneSSEStream();
+            };
+          }
+          this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
         }
-        this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
+      } catch (error) {
+        this._streamMapping.get(streamId)?.cleanup();
+        this._resumableStreams.delete(streamId);
+        for (const message of messages) {
+          if (isJSONRPCRequest(message)) {
+            this._requestToStreamMapping.delete(message.id);
+          }
+        }
+        throw error;
+      }
+      if (this._streamMapping.get(streamId)?.controller === streamController) {
+        keepAliveTimer = this.startKeepAlive(streamController, encoder);
       }
       return new Response(readable, { status: 200, headers: headers2 });
     } catch (error) {
@@ -13370,9 +13555,12 @@ data:
     if (protocolError2) {
       return protocolError2;
     }
-    await Promise.resolve(this._onsessionclosed?.(this.sessionId));
-    await this.close();
-    return new Response(null, { status: 200 });
+    try {
+      await Promise.resolve(this._onsessionclosed?.(this.sessionId));
+      return new Response(null, { status: 200 });
+    } finally {
+      await this.close();
+    }
   }
   validateSession(req) {
     if (this.sessionIdGenerator === undefined) {
@@ -13402,11 +13590,16 @@ data:
     return;
   }
   async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
     this._streamMapping.forEach(({ cleanup }) => {
       cleanup();
     });
     this._streamMapping.clear();
     this._requestResponseMap.clear();
+    this._resumableStreams.clear();
     this.onclose?.();
   }
   closeSSEStream(requestId) {
@@ -13441,7 +13634,7 @@ data:
       if (standaloneSse === undefined) {
         return;
       }
-      if (standaloneSse.controller && standaloneSse.encoder) {
+      if (standaloneSse.controller && standaloneSse.encoder && (eventId === undefined || !standaloneSse.replayedEventIds?.has(eventId))) {
         this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
       }
       return;
@@ -13450,13 +13643,19 @@ data:
     if (!streamId) {
       throw new Error(`No connection established for request ID: ${String(requestId)}`);
     }
-    const stream = this._streamMapping.get(streamId);
-    if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
+    let stream = this._streamMapping.get(streamId);
+    if (!this._enableJsonResponse) {
       let eventId;
       if (this._eventStore) {
         eventId = await this._eventStore.storeEvent(streamId, message);
+        stream = this._streamMapping.get(streamId);
+      }
+      if (stream?.controller && stream?.encoder && (eventId === undefined || !stream.replayedEventIds?.has(eventId))) {
+        const written = this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
+        if (written && eventId !== undefined) {
+          this._resumableStreams.add(streamId);
+        }
       }
-      this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
     }
     if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
       this._requestResponseMap.set(requestId, message);
@@ -13464,6 +13663,25 @@ data:
       const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id));
       if (allResponsesReady) {
         if (!stream) {
+          if (this._closed) {
+            for (const id of relatedIds) {
+              this._requestResponseMap.delete(id);
+              this._requestToStreamMapping.delete(id);
+            }
+            return;
+          }
+          if (!this._enableJsonResponse && this._eventStore && this._resumableStreams.has(streamId)) {
+            for (const id of relatedIds) {
+              this._requestResponseMap.delete(id);
+              this._requestToStreamMapping.delete(id);
+            }
+            this._resumableStreams.delete(streamId);
+            return;
+          }
+          for (const id of relatedIds) {
+            this._requestResponseMap.delete(id);
+            this._requestToStreamMapping.delete(id);
+          }
           throw new Error(`No connection established for request ID: ${String(requestId)}`);
         }
         if (this._enableJsonResponse && stream.resolveJson) {
@@ -13486,6 +13704,7 @@ data:
           this._requestResponseMap.delete(id);
           this._requestToStreamMapping.delete(id);
         }
+        this._resumableStreams.delete(streamId);
       }
     }
   }
@@ -13720,6 +13939,7 @@ async function handleMcp(req, res, transports, sessionActivity = {}, sessionAgen
       }
       const server = await createServer({
         preloadedTools,
+        enabledTools: configs.find((config) => config.key === "SWARM_ENABLED_TOOLS")?.value ?? process.env.SWARM_ENABLED_TOOLS,
         scriptsOnly: resolveScriptsOnlyMode({
           env: process.env.SCRIPTS_ONLY_MCP,
           configValue
@@ -17984,6 +18204,7 @@ init_db2();
 init_memory();
 init_constants2();
 init_types();
+init_openrouter_base_url();
 
 // src/http/status.ts
 init_zod();
@@ -18707,6 +18928,7 @@ async function handleMemoryProbe(body) {
     const client = new OpenAI({
       baseURL: endpoint.toString(),
       apiKey,
+      defaultHeaders: getOpenRouterAttributionHeaders(endpoint.toString()),
       timeout: 15000,
       maxRetries: 0,
       fetchOptions: { redirect: "manual" }
@@ -32848,7 +33070,7 @@ async function shutdown() {
     sessionsProcessed: getServerSessionsProcessed()
   });
   if (hasCapability("scheduling")) {
-    const { stopScheduler } = await import("./index-bn6cy8ps.js");
+    const { stopScheduler } = await import("./index-ekywyv2v.js");
     stopScheduler();
   }
   stopHeartbeat();
@@ -32857,7 +33079,7 @@ async function shutdown() {
   await stopScriptRunSupervisor();
   await stopSlackApp();
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
-    const { stopOAuthKeepalive } = await import("./keepalive-3xspa9jw.js");
+    const { stopOAuthKeepalive } = await import("./keepalive-4aezx4bj.js");
     await stopOAuthKeepalive();
   }
   stopOAuthPendingGc();
@@ -32932,15 +33154,15 @@ try {
   console.warn("[startup] CAPABILITIES upgrade seed failed (non-fatal):", err);
 }
 try {
-  const { ensurePricingSeeded } = await import("./boot-seeds-vvzs1zhk.js");
+  const { ensurePricingSeeded } = await import("./boot-seeds-22tx8a53.js");
   ensurePricingSeeded();
-  const { startPricingRefreshLoop } = await import("./pricing-refresh-atnkngqs.js");
+  const { startPricingRefreshLoop } = await import("./pricing-refresh-mjrqvnvw.js");
   startPricingRefreshLoop();
 } catch (err) {
   console.error("[startup] Failed to seed pricing rows:", err);
 }
 try {
-  const { ensureRbacSeeded } = await import("./boot-seeds-vvzs1zhk.js");
+  const { ensureRbacSeeded } = await import("./boot-seeds-22tx8a53.js");
   ensureRbacSeeded();
 } catch (err) {
   console.error("[startup] Failed to sync RBAC seed rows:", err);
@@ -32948,7 +33170,7 @@ try {
     throw err;
 }
 try {
-  const { runAllSeeders } = await import("./index-f8xnqrye.js");
+  const { runAllSeeders } = await import("./index-cx1sb9bq.js");
   await runAllSeeders({ scriptEmbeddingMode: "skip" });
 } catch (err) {
   console.error("[startup] Failed to seed built-in entities:", err);
@@ -33008,37 +33230,37 @@ httpServer.listen(port, async () => {
   await initWorkflows();
   await startScriptRunSupervisor(getMcpBaseUrl());
   if (hasCapability("scheduling")) {
-    const { startScheduler } = await import("./index-bn6cy8ps.js");
-    const { getExecutorRegistry: getExecutorRegistry2 } = await import("./index-n99fycq7.js");
+    const { startScheduler } = await import("./index-ekywyv2v.js");
+    const { getExecutorRegistry: getExecutorRegistry2 } = await import("./index-t4g06w93.js");
     const intervalMs = Number(process.env.SCHEDULER_INTERVAL_MS) || 1e4;
     startScheduler(getExecutorRegistry2(), intervalMs, {
       runId: globalState.__runId
     });
   }
   if (!isEnvFlagEnabled("HEARTBEAT_DISABLE", false)) {
-    const { startHeartbeat } = await import("./index-dkfxpkmm.js");
+    const { startHeartbeat } = await import("./index-bt8wkv1w.js");
     const heartbeatMs = Number(process.env.HEARTBEAT_INTERVAL_MS) || 90000;
     startHeartbeat(heartbeatMs);
   }
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
-    const { startOAuthKeepalive } = await import("./keepalive-3xspa9jw.js");
+    const { startOAuthKeepalive } = await import("./keepalive-4aezx4bj.js");
     startOAuthKeepalive();
   }
   if (process.env.OAUTH_REFRESH_SWEEP_DISABLE !== "true") {
-    const { startOAuthRefreshSweep } = await import("./oauth-refresh-sweep-sh9q25xp.js");
+    const { startOAuthRefreshSweep } = await import("./oauth-refresh-sweep-wm4ctjfj.js");
     startOAuthRefreshSweep();
   }
   startOAuthPendingGc();
   await startMemoryGc();
   await startDbRetention();
   startHumanFreeDrain();
-  import("./boot-reembed-s7k7c6v2.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
+  import("./boot-reembed-fmp5ww69.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
     console.error("[boot-reembed] startup backfill failed (non-fatal):", err);
   });
-  import("./boot-reembed-998jtpdg.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
+  import("./boot-reembed-1ze5853n.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
     console.error("[boot-reembed-scripts] startup backfill failed (non-fatal):", err);
   });
-  import("./boot-scrub-sweep-nepsk4t1.js").then(({ runBootScrubSweep }) => runBootScrubSweep()).catch((err) => {
+  import("./boot-scrub-sweep-cbp8xd4e.js").then(({ runBootScrubSweep }) => runBootScrubSweep()).catch((err) => {
     console.error("[boot-scrub-sweep] startup scrub failed (non-fatal):", err);
   });
 }).on("error", (err) => {