portkey-admin-mcp 0.8.0 → 0.10.0

package/build/server.js

@@ -137,6 +137,7 @@ var Logger = {
 // src/services/base.service.ts
 var DEFAULT_BASE_URL = "https://api.portkey.ai/v1";
 var DEFAULT_PUBLIC_BASE_URL = "https://api.portkey.ai";
+var MISSING_API_KEY_PLACEHOLDER = "__PORTKEY_API_KEY_NOT_CONFIGURED__";
 var PRIVATE_BASE_URL_OVERRIDE_HINT = "Set PORTKEY_ALLOW_PRIVATE_BASE_URL=true to allow self-hosted gateways on loopback or private networks.";
 var INSECURE_HTTP_OVERRIDE_HINT = "Set PORTKEY_ALLOW_INSECURE_HTTP=true only for a trusted self-hosted gateway when TLS is unavailable.";
 function isPrivateOrLocalHost(hostname) {
@@ -250,6 +251,11 @@ var BaseService = class {
     return body ? JSON.stringify(body) : void 0;
   }
   async executeRequest(method, path, options = {}) {
+    if ((options.authenticate ?? true) && this.apiKey === MISSING_API_KEY_PLACEHOLDER) {
+      throw new Error(
+        "PORTKEY_API_KEY is not configured. Set the PORTKEY_API_KEY environment variable to a valid Portkey Admin API key."
+      );
+    }
     const requestId = crypto.randomUUID();
     const url = this.buildUrl(path, options.params, options.baseUrl);
     const startTime = Date.now();
@@ -1812,7 +1818,6 @@ var WorkspacesService = class extends BaseService {
 
 // src/services/index.ts
 import { createHmac, randomBytes } from "node:crypto";
-var MISSING_API_KEY_PLACEHOLDER = "__PORTKEY_API_KEY_NOT_CONFIGURED__";
 var SERVICE_CACHE_HMAC_KEY = randomBytes(32);
 function resolvePortkeyApiKey(apiKey) {
   const resolvedApiKey = apiKey ?? process.env.PORTKEY_API_KEY;
@@ -2701,6 +2706,14 @@ function buildConfigPayload(params) {
 function hasConfigSettings(config) {
   return config.cache !== void 0 || config.retry !== void 0 || config.strategy !== void 0 || config.targets !== void 0;
 }
+var createConfigSchema = z5.object(CONFIGS_TOOL_SCHEMAS.createConfig).superRefine((value, ctx) => {
+  if (!hasConfigSettings(buildConfigPayload(value))) {
+    ctx.addIssue({
+      code: z5.ZodIssueCode.custom,
+      message: "At least one config setting (cache_mode, retry_attempts, strategy_mode, or targets) must be provided"
+    });
+  }
+});
 function registerConfigsTools(server, service) {
   server.tool(
     "list_configs",
@@ -2766,25 +2779,15 @@ function registerConfigsTools(server, service) {
     "Create a config that defines routing, cache, retry, and targets for requests; use update_config to modify an existing one and list_config_versions for history. At least one setting is required, new configs become active immediately once referenced by a key or prompt, and the call returns the new id and version_id.",
     CONFIGS_TOOL_SCHEMAS.createConfig,
     async (params) => {
-      const config = buildConfigPayload(params);
-      if (!hasConfigSettings(config)) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error creating configuration: At least one config setting (cache_mode, retry_attempts, strategy_mode, or targets) must be provided"
-            }
-          ],
-          isError: true
-        };
-      }
+      const validated = createConfigSchema.parse(params);
+      const config = buildConfigPayload(validated);
       const result = await service.configs.createConfig({
-        name: params.name,
+        name: validated.name,
         config,
-        workspace_id: params.workspace_id
+        workspace_id: validated.workspace_id
       });
       return jsonResult({
-        message: `Successfully created configuration "${params.name}"`,
+        message: `Successfully created configuration "${validated.name}"`,
         id: result.id,
         version_id: result.version_id
       });
@@ -3413,6 +3416,16 @@ var INTEGRATIONS_TOOL_SCHEMAS = {
     default_provider_slug: z8.string().optional().describe("Default slug for providers auto-created in workspaces")
   }
 };
+var updateIntegrationWorkspacesSchema = z8.object(INTEGRATIONS_TOOL_SCHEMAS.updateIntegrationWorkspaces).superRefine((value, ctx) => {
+  const hasGlobalLimits = value.global_credit_limit !== void 0 || value.global_alert_threshold !== void 0 || value.global_rate_limit_rpm !== void 0;
+  if (hasGlobalLimits && value.global_workspace_access_enabled === void 0) {
+    ctx.addIssue({
+      code: z8.ZodIssueCode.custom,
+      path: ["global_workspace_access_enabled"],
+      message: "global_workspace_access_enabled is required when setting global limits."
+    });
+  }
+});
 function buildIntegrationConfigurations(params) {
   const configurations = {};
   if (params.api_version !== void 0)
@@ -3690,19 +3703,8 @@ function registerIntegrationsTools(server, service) {
       idempotentHint: true,
       openWorldHint: true
     },
-    async (params) => {
-      const hasGlobalLimits = params.global_credit_limit !== void 0 || params.global_alert_threshold !== void 0 || params.global_rate_limit_rpm !== void 0;
-      if (hasGlobalLimits && params.global_workspace_access_enabled === void 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "global_workspace_access_enabled is required when setting global limits."
-            }
-          ],
-          isError: true
-        };
-      }
+    async (rawParams) => {
+      const params = updateIntegrationWorkspacesSchema.parse(rawParams);
       const globalUsageLimits = params.global_credit_limit !== void 0 || params.global_alert_threshold !== void 0 ? [
         {
           type: "cost",
@@ -4180,23 +4182,21 @@ var LABELS_TOOL_SCHEMAS = {
     label_id: z10.string().describe("Label ID to delete")
   }
 };
+var createPromptLabelSchema = z10.object(LABELS_TOOL_SCHEMAS.createPromptLabel).superRefine((value, ctx) => {
+  if (!value.organisation_id && !value.workspace_id) {
+    ctx.addIssue({
+      code: z10.ZodIssueCode.custom,
+      message: "Either organisation_id or workspace_id is required"
+    });
+  }
+});
 function registerLabelsTools(server, service) {
   server.tool(
     "create_prompt_label",
     "Create a prompt label for tagging prompt versions such as production, staging, or experiment. Requires either organisation_id or workspace_id to set scope, returns the new label id, and does not assign it to any versions yet.",
     LABELS_TOOL_SCHEMAS.createPromptLabel,
-    async (params) => {
-      if (!params.organisation_id && !params.workspace_id) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Either organisation_id or workspace_id is required"
-            }
-          ],
-          isError: true
-        };
-      }
+    async (rawParams) => {
+      const params = createPromptLabelSchema.parse(rawParams);
       const result = await service.labels.createLabel({
         name: params.name,
         organisation_id: params.organisation_id,
@@ -4606,12 +4606,13 @@ var logExportFieldSchema = z12.enum([
   "prompt_slug",
   "metadata"
 ]);
-var getLogInputSchema = z12.object({
+var getLogShape = {
   log_id: z12.string().describe("Gateway log ID to retrieve"),
   path_format: z12.enum(["v1", "v2"]).optional().describe("Log storage path format; defaults to v1"),
   created_at: z12.iso.datetime({ offset: true }).optional().describe("Log creation timestamp in ISO 8601 format; required for v2"),
   type: z12.enum(["hooks"]).optional().describe("Set to hooks when retrieving a hook execution log")
-}).superRefine((input, context) => {
+};
+var getLogSchema = z12.object(getLogShape).superRefine((input, context) => {
   if (input.path_format === "v2" && input.created_at === void 0) {
     context.addIssue({
       code: "custom",
@@ -4692,7 +4693,7 @@ function registerLoggingTools(server, service) {
     "get_log",
     {
       description: "Get one gateway request log by ID, including its request, response, usage, cost, and metadata payload when available. For path_format v2, also provide the log's created_at timestamp.",
-      inputSchema: getLogInputSchema,
+      inputSchema: getLogShape,
       annotations: {
         title: "Get Gateway Log",
         readOnlyHint: true,
@@ -4701,7 +4702,8 @@ function registerLoggingTools(server, service) {
         openWorldHint: true
       }
     },
-    async (params) => {
+    async (rawParams) => {
+      const params = getLogSchema.parse(rawParams);
       const result = await service.logging.getLog(params.log_id, {
         path_format: params.path_format,
         created_at: params.created_at,
@@ -4993,6 +4995,17 @@ var MCP_INTEGRATIONS_TOOL_SCHEMAS = {
     ).min(1).describe("Array of workspace access updates")
   }
 };
+var createMcpIntegrationSchema = z13.object(MCP_INTEGRATIONS_TOOL_SCHEMAS.createMcpIntegration).superRefine((value, ctx) => {
+  if (value.auth_type === "headers" && (!value.custom_headers || Object.keys(value.custom_headers).length === 0) && !value.secret_mappings?.some(
+    (mapping) => mapping.target_field === "configurations.custom_headers"
+  )) {
+    ctx.addIssue({
+      code: z13.ZodIssueCode.custom,
+      path: ["custom_headers"],
+      message: "custom_headers must be provided when auth_type is 'headers'"
+    });
+  }
+});
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
@@ -5071,20 +5084,8 @@ function registerMcpIntegrationsTools(server, service) {
       idempotentHint: false,
       openWorldHint: true
     },
-    async (params) => {
-      if (params.auth_type === "headers" && (!params.custom_headers || Object.keys(params.custom_headers).length === 0) && !params.secret_mappings?.some(
-        (mapping) => mapping.target_field === "configurations.custom_headers"
-      )) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: custom_headers must be provided when auth_type is 'headers'"
-            }
-          ],
-          isError: true
-        };
-      }
+    async (rawParams) => {
+      const params = createMcpIntegrationSchema.parse(rawParams);
       const { custom_headers, ...rest } = params;
       const result = await service.mcpIntegrations.createMcpIntegration({
         ...rest,
@@ -5921,6 +5922,28 @@ var PROMPTS_TOOL_SCHEMAS = {
     )
   }
 };
+var createPromptSchema = z17.object(PROMPTS_TOOL_SCHEMAS.createPrompt).superRefine((value, ctx) => {
+  if (!value.model && !value.ai_model_id && !value.finetune_id) {
+    ctx.addIssue({
+      code: z17.ZodIssueCode.custom,
+      message: "At least one of model, ai_model_id, or finetune_id must be provided"
+    });
+  }
+  if (value.string === void 0 && value.messages === void 0) {
+    ctx.addIssue({
+      code: z17.ZodIssueCode.custom,
+      message: "Provide either string or messages"
+    });
+  }
+});
+var migratePromptSchema = z17.object(PROMPTS_TOOL_SCHEMAS.migratePrompt).superRefine((value, ctx) => {
+  if (value.string === void 0 && value.messages === void 0) {
+    ctx.addIssue({
+      code: z17.ZodIssueCode.custom,
+      message: "Provide either string or messages"
+    });
+  }
+});
 function normalizePromptTemplateString(params) {
   if (params.string !== void 0) {
     return params.string;
@@ -5995,30 +6018,9 @@ function registerPromptsTools(server, service) {
     "create_prompt",
     "Create a new prompt template and initial version. Use this for first-time setup; use migrate_prompt for idempotent CI/CD flows. Accepts plain text or structured chat messages, creates a new version immediately, and returns the prompt id, slug, and version id. For multi-message chat prompts pass messages (preferred) or a JSON-encoded array as string.",
     PROMPTS_TOOL_SCHEMAS.createPrompt,
-    async (params) => {
-      if (!params.model && !params.ai_model_id && !params.finetune_id) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error creating prompt: At least one of model, ai_model_id, or finetune_id must be provided"
-            }
-          ],
-          isError: true
-        };
-      }
+    async (rawParams) => {
+      const params = createPromptSchema.parse(rawParams);
       const templateString = normalizePromptTemplateString(params);
-      if (templateString === void 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error creating prompt: Provide either string or messages"
-            }
-          ],
-          isError: true
-        };
-      }
       if (params.dry_run) {
         return jsonResult({
           dry_run: true,
@@ -6128,14 +6130,18 @@ function registerPromptsTools(server, service) {
       });
       if (dry_run) {
         const current = await service.prompts.getPrompt(prompt_id);
+        const changes = Object.keys(updateData).filter(
+          (k) => updateData[k] !== void 0
+        );
+        if (messages !== void 0 && !changes.includes("string")) {
+          changes.push("string");
+        }
         return jsonResult({
           dry_run: true,
           action: "update",
           message: `Would update prompt "${current.name}"`,
           current_version: current.current_version?.version_number ?? null,
-          changes: Object.keys(updateData).filter(
-            (k) => updateData[k] !== void 0
-          )
+          changes
         });
       }
       const result = await service.prompts.updatePrompt(prompt_id, {
@@ -6273,19 +6279,9 @@ function registerPromptsTools(server, service) {
       idempotentHint: true,
       openWorldHint: false
     },
-    async (params) => {
+    async (rawParams) => {
+      const params = migratePromptSchema.parse(rawParams);
       const templateString = normalizePromptTemplateString(params);
-      if (templateString === void 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error migrating prompt: Provide either string or messages"
-            }
-          ],
-          isError: true
-        };
-      }
       const result = await service.prompts.migratePrompt({
         name: params.name,
         app: params.app,
@@ -7251,7 +7247,7 @@ var scimWorkspaceMappingBaseShape = {
   workspace_id: z22.string().describe("Portkey workspace ID that the SCIM group should access"),
   role: z22.enum(["admin", "member", "manager"]).describe("Workspace role automatically granted to group members")
 };
-var createScimWorkspaceMappingInputSchema = z22.object({
+var createScimWorkspaceMappingShape = {
   ...scimWorkspaceMappingBaseShape,
   scim_group_id: z22.string().min(1).optional().describe(
     "Existing identity-provider SCIM group ID; provide this or scim_group_name, but not both"
@@ -7259,7 +7255,8 @@ var createScimWorkspaceMappingInputSchema = z22.object({
   scim_group_name: z22.string().min(1).optional().describe(
     "Existing SCIM group display name; provide this or scim_group_id, but not both"
   )
-}).superRefine((input, context) => {
+};
+var createScimWorkspaceMappingSchema = z22.object(createScimWorkspaceMappingShape).superRefine((input, context) => {
   if (Boolean(input.scim_group_id) === Boolean(input.scim_group_name)) {
     context.addIssue({
       code: "custom",
@@ -7414,7 +7411,7 @@ function registerWorkspacesTools(server, service) {
     "create_scim_workspace_mapping",
     {
       description: "Map one identity-provider SCIM group to a Portkey workspace role so current and future group members receive access automatically. Provide exactly one of scim_group_id or scim_group_name; a name can pre-create the Portkey SCIM group before the IdP provisions it. Use list_scim_groups to discover existing groups and list_workspaces for the workspace ID. This changes access provisioning and is distinct from add_workspace_member, which grants one user directly.",
-      inputSchema: createScimWorkspaceMappingInputSchema,
+      inputSchema: createScimWorkspaceMappingShape,
       annotations: {
         title: "Create SCIM Workspace Mapping",
         readOnlyHint: false,
@@ -7423,7 +7420,8 @@ function registerWorkspacesTools(server, service) {
         openWorldHint: true
       }
     },
-    async (params) => {
+    async (rawParams) => {
+      const params = createScimWorkspaceMappingSchema.parse(rawParams);
       let request;
       if (params.scim_group_id !== void 0) {
         request = {
@@ -7784,7 +7782,25 @@ function augmentToolDescription(toolName, description) {
   }
   return `${description} ${ENTERPRISE_GATED_DESCRIPTION_NOTE}`;
 }
+function formatZodIssues(error) {
+  return error.issues.map((issue) => {
+    const path = issue.path.join(".");
+    if (!path) {
+      return issue.message;
+    }
+    const namesPath = new RegExp(`\\b${escapeRegExp(path)}\\b`).test(
+      issue.message
+    );
+    return namesPath ? issue.message : `${path}: ${issue.message}`;
+  }).join("; ");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function getToolErrorMessage(error) {
+  if (error instanceof z23.ZodError) {
+    return formatZodIssues(error);
+  }
   if (error instanceof Error && error.message) {
     return error.message;
   }
@@ -7931,14 +7947,14 @@ function wrapToolCallback(toolName, callback) {
       return normalizeToolResult(await callback(...args));
     } catch (error) {
       const message = getToolErrorMessage(error);
+      const isValidationError = error instanceof z23.ZodError;
+      const text = isValidationError ? `Invalid arguments for "${toolName}": ${message}` : `Tool "${toolName}" failed: ${message}`;
       Logger.error("Tool callback failed", {
         error: message,
         metadata: { toolName }
       });
       return normalizeToolResult({
-        content: [
-          { type: "text", text: `Tool "${toolName}" failed: ${message}` }
-        ],
+        content: [{ type: "text", text }],
         isError: true
       });
     }
@@ -8079,6 +8095,21 @@ function registerAllTools(server, service, options = {}) {
 // src/lib/auth.ts
 import crypto2 from "node:crypto";
 import { createRemoteJWKSet, jwtVerify } from "jose";
+
+// src/lib/request-path.ts
+function canonicalizeRequestPath(path) {
+  const normalized = path.toLowerCase();
+  return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function isMcpRequestPath(path) {
+  return canonicalizeRequestPath(path) === "/mcp";
+}
+function isHealthOrReadyPath(path) {
+  const canonical = canonicalizeRequestPath(path);
+  return canonical === "/health" || canonical === "/ready";
+}
+
+// src/lib/auth.ts
 function getPrincipalOwnerKey(principal) {
   return crypto2.createHash("sha256").update(principal.id, "utf8").digest("hex");
 }
@@ -8299,7 +8330,7 @@ async function verifyClerkToken(token, config) {
   return authorizeClerkClaims(payload, config);
 }
 async function mcpAuthMiddleware(req, res, next) {
-  if (!req.path.startsWith("/mcp")) {
+  if (!isMcpRequestPath(req.path)) {
     next();
     return;
   }
@@ -8428,6 +8459,15 @@ function getServerConfig() {
       `Invalid MCP_EVENT_TTL_SECONDS value: ${eventStoreTtlStr}. Must be a positive integer`
     );
   }
+  const eventStoreCommandTimeoutStr = (process.env.MCP_EVENT_STORE_COMMAND_TIMEOUT_MS || "5000").trim();
+  const eventStoreCommandTimeoutMs = parseStrictInteger(
+    eventStoreCommandTimeoutStr
+  );
+  if (Number.isNaN(eventStoreCommandTimeoutMs) || eventStoreCommandTimeoutMs < 0) {
+    throw new Error(
+      `Invalid MCP_EVENT_STORE_COMMAND_TIMEOUT_MS value: ${eventStoreCommandTimeoutStr}. Must be a non-negative integer (0 disables the timeout)`
+    );
+  }
   const redisUrl = process.env.MCP_REDIS_URL?.trim() || process.env.REDIS_URL?.trim();
   if (eventStoreMode === "redis" && !redisUrl) {
     throw new Error(
@@ -8487,7 +8527,8 @@ function getServerConfig() {
       ttlSeconds: eventStoreTtlSeconds,
       redisUrl,
       redisKeyPrefix,
-      encryptionKey: eventEncryptionKey
+      encryptionKey: eventEncryptionKey,
+      commandTimeoutMs: eventStoreCommandTimeoutMs
     },
     protocol,
     port,
@@ -8719,13 +8760,15 @@ var RedisEventStore = class _RedisEventStore {
   keyPrefix;
   ownerKey;
   encryptionKey;
+  commandTimeoutMs;
   connection;
-  constructor(redisUrl, keyPrefix, ttlSeconds, ownerKey, encryptionKey, connection = {}) {
+  constructor(redisUrl, keyPrefix, ttlSeconds, ownerKey, encryptionKey, commandTimeoutMs, connection = {}) {
     this.redisUrl = redisUrl;
     this.ttlSeconds = ttlSeconds;
     this.keyPrefix = keyPrefix;
     this.ownerKey = ownerKey;
     this.encryptionKey = encryptionKey;
+    this.commandTimeoutMs = commandTimeoutMs;
     this.connection = connection;
   }
   get client() {
@@ -8741,6 +8784,7 @@ var RedisEventStore = class _RedisEventStore {
       this.ttlSeconds,
       ownerKey,
       this.encryptionKey,
+      this.commandTimeoutMs,
       this.connection
     );
   }
@@ -8762,11 +8806,19 @@ var RedisEventStore = class _RedisEventStore {
       this.connection.client = createClient({
         url: this.redisUrl,
         // node-redis v6 defaults to RESP3, a 5-second command timeout, and a
-        // 30-second keepalive delay. Keep the event store's v5 behavior stable
-        // while taking the v6 fixes and supported runtime baseline.
+        // 30-second keepalive delay. storeEvent/replayEventsAfter sit on the
+        // MCP request-critical path (SSE sends, GET replay), so an unbounded
+        // command wait here would hang requests indefinitely if Redis accepts
+        // TCP but stalls on replies. Keep RESP2 for v5-compatible replies, but
+        // use a bounded, configurable command timeout (default 5s, matching
+        // node-redis's own default) instead of disabling it. Set
+        // MCP_EVENT_STORE_COMMAND_TIMEOUT_MS=0 to restore the old unbounded
+        // (v5-compatible) behavior.
         RESP: 2,
         socket: { keepAliveInitialDelay: 5e3 },
-        commandOptions: { timeout: void 0 }
+        commandOptions: {
+          timeout: this.commandTimeoutMs === 0 ? void 0 : this.commandTimeoutMs
+        }
       });
       this.connection.client.on("error", (error) => {
         Logger.error("Redis event store error", {
@@ -8946,7 +8998,8 @@ function createManagedEventStore(config) {
     config.eventStore.redisKeyPrefix,
     config.eventStore.ttlSeconds,
     "internal",
-    encryptionKey
+    encryptionKey,
+    config.eventStore.commandTimeoutMs
   );
   return {
     mode: "redis",
@@ -9222,7 +9275,7 @@ function isAllowedHost(host) {
   });
 }
 function originValidationMiddleware(req, res, next) {
-  if (req.path === "/health" || req.path === "/ready") {
+  if (isHealthOrReadyPath(req.path)) {
     next();
     return;
   }
@@ -9239,7 +9292,7 @@ function originValidationMiddleware(req, res, next) {
   next();
 }
 function hostValidationMiddleware(req, res, next) {
-  if (req.path === "/health" || req.path === "/ready") {
+  if (isHealthOrReadyPath(req.path)) {
     next();
     return;
   }
@@ -9371,23 +9424,26 @@ function resolveRateLimitRedisUrl(store) {
   }
   return redisUrl;
 }
-var rateLimitEnabled = process.env.RATE_LIMIT_ENABLED?.trim().toLowerCase() !== "false";
-var rateLimitStore = resolveRateLimitStore();
-if (rateLimitEnabled && rateLimitStore === "memory" && process.env.NODE_ENV?.trim().toLowerCase() === "production" && !isExplicitlyEnabled2(process.env.RATE_LIMIT_SINGLE_PROCESS)) {
-  throw new Error(
-    "Production in-memory rate limiting requires RATE_LIMIT_SINGLE_PROCESS=true. Use RATE_LIMIT_STORE=redis for multi-instance deployments."
-  );
-}
-var RATE_LIMIT_CONFIG = {
-  enabled: rateLimitEnabled,
-  store: rateLimitStore,
-  maxTokens: parsePositiveIntegerEnv("RATE_LIMIT_MAX", 60),
-  windowMs: parsePositiveIntegerEnv("RATE_LIMIT_WINDOW_MS", 6e4),
-  refillRate: parsePositiveIntegerEnv("RATE_LIMIT_REFILL", 60),
-  maxBuckets: parsePositiveIntegerEnv("RATE_LIMIT_MAX_BUCKETS", 1e4),
-  redisUrl: resolveRateLimitRedisUrl(rateLimitStore),
-  redisKeyPrefix: process.env.RATE_LIMIT_REDIS_KEY_PREFIX?.trim() || "mcp:rate-limit"
-};
+function resolveRateLimitConfig() {
+  const enabled = process.env.RATE_LIMIT_ENABLED?.trim().toLowerCase() !== "false";
+  const store = resolveRateLimitStore();
+  if (enabled && store === "memory" && process.env.NODE_ENV?.trim().toLowerCase() === "production" && !isExplicitlyEnabled2(process.env.RATE_LIMIT_SINGLE_PROCESS)) {
+    throw new Error(
+      "Production in-memory rate limiting requires RATE_LIMIT_SINGLE_PROCESS=true. Use RATE_LIMIT_STORE=redis for multi-instance deployments."
+    );
+  }
+  return {
+    enabled,
+    store,
+    maxTokens: parsePositiveIntegerEnv("RATE_LIMIT_MAX", 60),
+    windowMs: parsePositiveIntegerEnv("RATE_LIMIT_WINDOW_MS", 6e4),
+    refillRate: parsePositiveIntegerEnv("RATE_LIMIT_REFILL", 60),
+    maxBuckets: parsePositiveIntegerEnv("RATE_LIMIT_MAX_BUCKETS", 1e4),
+    redisUrl: resolveRateLimitRedisUrl(store),
+    redisKeyPrefix: process.env.RATE_LIMIT_REDIS_KEY_PREFIX?.trim() || "mcp:rate-limit"
+  };
+}
+var RATE_LIMIT_CONFIG = resolveRateLimitConfig();
 function getRateLimitConfig() {
   return RATE_LIMIT_CONFIG;
 }
@@ -9520,11 +9576,11 @@ function applyRateLimit(scope, req, res, next) {
     next();
     return;
   }
-  if (req.path === "/health" || req.path === "/ready") {
+  if (isHealthOrReadyPath(req.path)) {
     next();
     return;
   }
-  if (scope === "authentication" && req.path !== "/mcp") {
+  if (scope === "authentication" && !isMcpRequestPath(req.path)) {
     next();
     return;
   }
@@ -10378,14 +10434,16 @@ function createMcpPostHandler(deps) {
     try {
       await transport.handleRequest(req, res, req.body);
     } catch (error) {
-      if (hasReservedSessionSlot) {
-        sessionStore.releaseReservation();
-      }
       respondJsonRpcInternalError(
         res,
         sessionId ? "POST /mcp stateful session" : "POST /mcp stateful initialize",
         error
       );
+    } finally {
+      if (hasReservedSessionSlot) {
+        sessionStore.releaseReservation();
+        hasReservedSessionSlot = false;
+      }
     }
   };
 }
@@ -10421,143 +10479,150 @@ function createMcpGetHandler(deps) {
         );
         return;
       }
-      const replayEventStore = managedEventStore.eventStoreForOwner(ownerKey);
-      if (!replayEventStore || !managedEventStore.acquireReplayLease) {
-        res.setHeader("Allow", "POST");
-        respondJsonRpcClientError(
-          res,
-          405,
-          "Stateless GET /mcp replay requires MCP_EVENT_STORE=memory or redis",
-          -32e3
-        );
-        return;
-      }
-      const lastEventId = req.headers["last-event-id"];
-      if (typeof lastEventId !== "string" || lastEventId.length === 0) {
-        res.setHeader("Allow", "POST");
-        respondJsonRpcClientError(
-          res,
-          405,
-          "Stateless GET /mcp only supports replay with Last-Event-ID",
-          -32e3
-        );
-        return;
-      }
-      if (!req.headers.accept?.includes("text/event-stream")) {
-        respondJsonRpcClientError(
-          res,
-          406,
-          "Not Acceptable: Client must accept text/event-stream",
-          -32e3
-        );
-        return;
-      }
-      const protocolError = validateRequiredProtocolVersion(
-        getMcpProtocolVersion(req)
-      );
-      if (protocolError) {
-        respondJsonRpcClientError(res, 400, protocolError, -32e3);
-        return;
-      }
+      let releaseReplaySlot;
+      const replaySlot = new Promise((resolve) => {
+        releaseReplaySlot = resolve;
+      });
+      activeReplayOperations.add(replaySlot);
       try {
-        const lease = await managedEventStore.acquireReplayLease(
-          lastEventId,
-          ownerKey
+        const replayEventStore = managedEventStore.eventStoreForOwner(ownerKey);
+        if (!replayEventStore || !managedEventStore.acquireReplayLease) {
+          res.setHeader("Allow", "POST");
+          respondJsonRpcClientError(
+            res,
+            405,
+            "Stateless GET /mcp replay requires MCP_EVENT_STORE=memory or redis",
+            -32e3
+          );
+          return;
+        }
+        const lastEventId = req.headers["last-event-id"];
+        if (typeof lastEventId !== "string" || lastEventId.length === 0) {
+          res.setHeader("Allow", "POST");
+          respondJsonRpcClientError(
+            res,
+            405,
+            "Stateless GET /mcp only supports replay with Last-Event-ID",
+            -32e3
+          );
+          return;
+        }
+        if (!req.headers.accept?.includes("text/event-stream")) {
+          respondJsonRpcClientError(
+            res,
+            406,
+            "Not Acceptable: Client must accept text/event-stream",
+            -32e3
+          );
+          return;
+        }
+        const protocolError = validateRequiredProtocolVersion(
+          getMcpProtocolVersion(req)
         );
-        if (lease.status !== "acquired") {
-          if (lease.status === "missing") {
+        if (protocolError) {
+          respondJsonRpcClientError(res, 400, protocolError, -32e3);
+          return;
+        }
+        try {
+          const lease = await managedEventStore.acquireReplayLease(
+            lastEventId,
+            ownerKey
+          );
+          if (lease.status !== "acquired") {
+            if (lease.status === "missing") {
+              respondJsonRpcClientError(
+                res,
+                400,
+                "Invalid event ID format",
+                -32e3
+              );
+              return;
+            }
             respondJsonRpcClientError(
               res,
-              400,
-              "Invalid event ID format",
+              409,
+              "Conflict: Stream already has an active replay connection",
               -32e3
             );
             return;
           }
-          respondJsonRpcClientError(
-            res,
-            409,
-            "Conflict: Stream already has an active replay connection",
-            -32e3
-          );
-          return;
-        }
-        const replayOperation = (async () => {
-          try {
-            res.status(200);
-            res.setHeader("Content-Type", "text/event-stream");
-            res.setHeader("Cache-Control", "no-cache, no-transform");
-            res.flushHeaders();
-            let cursor = lastEventId;
-            let finalResponseSeen = false;
-            const deadline = Date.now() + 25e3;
-            while (getIsReady() && !res.destroyed && !finalResponseSeen) {
-              await replayEventStore.replayEventsAfter(cursor, {
-                send: async (eventId, message) => {
-                  cursor = eventId;
-                  finalResponseSeen = "id" in message && ("result" in message || "error" in message);
-                  if (!res.write(
-                    `event: message
+          const replayOperation = (async () => {
+            try {
+              res.status(200);
+              res.setHeader("Content-Type", "text/event-stream");
+              res.setHeader("Cache-Control", "no-cache, no-transform");
+              res.flushHeaders();
+              let cursor = lastEventId;
+              let finalResponseSeen = false;
+              const deadline = Date.now() + 25e3;
+              while (getIsReady() && !res.destroyed && !finalResponseSeen) {
+                await replayEventStore.replayEventsAfter(cursor, {
+                  send: async (eventId, message) => {
+                    cursor = eventId;
+                    finalResponseSeen = "id" in message && ("result" in message || "error" in message);
+                    if (!res.write(
+                      `event: message
 id: ${eventId}
 data: ${JSON.stringify(message)}
 
 `
-                  )) {
-                    await waitForResponseWritable(res);
+                    )) {
+                      await waitForResponseWritable(res);
+                    }
                   }
+                });
+                if (finalResponseSeen || res.destroyed) {
+                  break;
                 }
-              });
-              if (finalResponseSeen || res.destroyed) {
-                break;
-              }
-              if (Date.now() >= deadline) {
-                res.write(`id: ${cursor}
+                if (Date.now() >= deadline) {
+                  res.write(`id: ${cursor}
 data: 
 
 `);
-                break;
-              }
-              await new Promise((resolvePoll) => setTimeout(resolvePoll, 100));
-            }
-            if (!res.writableEnded && !res.destroyed) {
-              await new Promise((resolveResponse) => {
-                const done = () => resolveResponse();
-                res.once("finish", done);
-                res.once("close", done);
-                res.end();
-              });
-            }
-          } finally {
-            try {
-              await lease.release();
-            } catch (error) {
-              Logger.error("Failed to release stateless replay lease", {
-                metadata: {
-                  error: error instanceof Error ? error.message : String(error)
+                  break;
                 }
-              });
+                await new Promise(
+                  (resolvePoll) => setTimeout(resolvePoll, 100)
+                );
+              }
+              if (!res.writableEnded && !res.destroyed) {
+                await new Promise((resolveResponse) => {
+                  const done = () => resolveResponse();
+                  res.once("finish", done);
+                  res.once("close", done);
+                  res.end();
+                });
+              }
+            } finally {
+              try {
+                await lease.release();
+              } catch (error) {
+                Logger.error("Failed to release stateless replay lease", {
+                  metadata: {
+                    error: error instanceof Error ? error.message : String(error)
+                  }
+                });
+              }
             }
-          }
-        })();
-        activeReplayOperations.add(replayOperation);
-        try {
+          })();
           await replayOperation;
-        } finally {
-          activeReplayOperations.delete(replayOperation);
-        }
-      } catch (error) {
-        if (res.headersSent) {
-          Logger.error("GET /mcp stateless replay failed", {
-            metadata: {
-              error: error instanceof Error ? error.message : String(error)
+        } catch (error) {
+          if (res.headersSent) {
+            Logger.error("GET /mcp stateless replay failed", {
+              metadata: {
+                error: error instanceof Error ? error.message : String(error)
+              }
+            });
+            if (!res.writableEnded) {
+              res.end();
             }
-          });
-          if (!res.writableEnded) {
-            res.end();
+          } else {
+            respondJsonRpcInternalError(res, "GET /mcp stateless", error);
           }
-        } else {
-          respondJsonRpcInternalError(res, "GET /mcp stateless", error);
         }
+      } finally {
+        activeReplayOperations.delete(replaySlot);
+        releaseReplaySlot();
       }
       return;
     }
@@ -10594,6 +10659,45 @@ data:
         return;
       }
       sessionStore.touch(sessionId);
+      const lastEventId = req.headers["last-event-id"];
+      if (typeof lastEventId === "string" && lastEventId.length > 0 && managedEventStore.acquireReplayLease) {
+        const lease = await managedEventStore.acquireReplayLease(
+          lastEventId,
+          ownerKey
+        );
+        if (lease.status !== "acquired") {
+          if (lease.status === "missing") {
+            respondJsonRpcClientError(
+              res,
+              400,
+              "Invalid event ID format",
+              -32e3
+            );
+            return;
+          }
+          respondJsonRpcClientError(
+            res,
+            409,
+            "Conflict: Stream already has an active replay connection",
+            -32e3
+          );
+          return;
+        }
+        try {
+          await transport.handleRequest(req, res);
+        } finally {
+          try {
+            await lease.release();
+          } catch (error) {
+            Logger.error("Failed to release stateful replay lease", {
+              metadata: {
+                error: error instanceof Error ? error.message : String(error)
+              }
+            });
+          }
+        }
+        return;
+      }
       await transport.handleRequest(req, res);
     } else {
       res.status(404).json({
@@ -10667,9 +10771,9 @@ function createHttpAppRuntime() {
   const readyCheckMode = getReadyCheckMode();
   const requestBodyLimit = process.env.MCP_MAX_REQUEST_SIZE?.trim() || "1mb";
   const allowedOrigins = getAllowedOrigins();
-  const corsOriginConfig = allowedOrigins.includes(
-    "*"
-  ) ? true : allowedOrigins;
+  const corsOriginConfig = (origin, callback) => {
+    callback(null, validateOrigin(origin));
+  };
   if (allowedOrigins.includes("*") && authConfig.mode === "none") {
     Logger.warn(
       "CORS wildcard (ALLOWED_ORIGINS=*) combined with MCP_AUTH_MODE=none: all origins are accepted with no authentication. Do not expose this server publicly."
@@ -10708,7 +10812,6 @@ function createHttpAppRuntime() {
       } : false
     })
   );
-  app.use(express.json({ limit: requestBodyLimit }));
   if (authConfig.mode === "none") {
     app.use(hostValidationMiddleware);
   }
@@ -10721,13 +10824,14 @@ function createHttpAppRuntime() {
       standardHeaders: false,
       legacyHeaders: false,
       validate: false,
-      skip: (req) => !rateLimitConfig.enabled || req.path !== "/mcp",
+      skip: (req) => !rateLimitConfig.enabled || !isMcpRequestPath(req.path),
       message: { error: "Too Many Requests" }
     })
   );
   app.use(rateLimitMiddleware);
   app.use(mcpAuthMiddleware);
   app.use(principalRateLimitMiddleware);
+  app.use(express.json({ limit: requestBodyLimit }));
   app.use(
     (err, _req, res, next) => {
       const errorType = err && typeof err === "object" && "type" in err ? err.type : void 0;