@frontmcp/adapters 1.8.3 → 1.8.4

package/esm/index.mjs

@@ -183,7 +183,11 @@ var OpenApiSpecPoller = class {
 };
 
 // libs/adapters/src/openapi/openapi.security.ts
-import { createSecurityContext, SecurityResolver } from "mcp-from-openapi";
+import {
+  createSecurityContext,
+  SecurityResolver
+} from "mcp-from-openapi";
+import { PublicMcpError } from "@frontmcp/sdk";
 async function createSecurityContextFromAuth(tool2, ctx, options) {
   if (options.securityResolver) {
     return await options.securityResolver(tool2, ctx);
@@ -238,7 +242,7 @@ async function createSecurityContextFromAuth(tool2, ctx, options) {
             throw err;
           }
           const errorMessage = err instanceof Error ? err.message : String(err);
-          throw new Error(`authProviderMapper['${scheme}'] threw an error: ${errorMessage}`);
+          throw new Error(`authProviderMapper['${scheme}'] threw an error: ${errorMessage}`, { cause: err });
         }
       }
     }
@@ -286,19 +290,158 @@ function extractSecuritySchemes(tools) {
   }
   return schemes;
 }
+function describeSecuritySchemes(tools) {
+  const schemes = /* @__PURE__ */ new Map();
+  for (const tool2 of tools) {
+    for (const mapper of tool2.mapper) {
+      if (mapper.security?.scheme && !schemes.has(mapper.security.scheme)) {
+        schemes.set(mapper.security.scheme, mapper.security);
+      }
+    }
+  }
+  return schemes;
+}
+function schemeParametersOf(tools) {
+  const parameters = /* @__PURE__ */ new Map();
+  for (const tool2 of tools) {
+    for (const mapper of tool2.mapper) {
+      const scheme = mapper.security?.scheme;
+      if (scheme && !parameters.has(scheme)) parameters.set(scheme, mapper);
+    }
+  }
+  return parameters;
+}
+function headerCredentialSource(parameter, options) {
+  if (!parameter) return void 0;
+  const staticHeaders = new Headers(options.additionalHeaders ?? {});
+  if (carriesSchemeParameter(parameter, new URL("http://startup.invalid/"), staticHeaders)) return "static";
+  if (options.headersMapper && (parameter.type === "header" || parameter.type === "cookie")) return "per-request";
+  return void 0;
+}
+function isBearerScheme(security) {
+  if (!security || security.type !== "http") return false;
+  return (security.httpScheme ?? "bearer").toLowerCase() === "bearer";
+}
+function credentialFieldOf(security) {
+  if (security?.type === "apiKey") return "apiKey";
+  if (security?.type === "oauth2" || security?.type === "openIdConnect") return "oauth2Token";
+  if (security?.type === "http" && security.httpScheme?.toLowerCase() === "basic") return "basic";
+  return "jwt";
+}
+function formatMissingSecurityMappingsError(adapterName, tools, missingMappings) {
+  const schemes = describeSecuritySchemes(tools);
+  const fieldOf = (scheme) => credentialFieldOf(schemes.get(scheme));
+  const firstField = fieldOf(missingMappings[0] ?? "");
+  const bearerSchemes = missingMappings.filter((scheme) => isBearerScheme(schemes.get(scheme)));
+  const lines = [
+    `[OpenAPI Adapter: ${adapterName}] Invalid security configuration.`,
+    `Missing auth provider mappings for security schemes: ${missingMappings.join(", ")}`,
+    "",
+    "Your OpenAPI spec requires these security schemes, but no credential option covers them.",
+    "",
+    "Add one of the following to your adapter configuration:",
+    "",
+    "1. authProviderMapper (recommended): a function per scheme that returns the credential issued for the API:",
+    "   authProviderMapper: {",
+    ...missingMappings.map((scheme) => `     '${scheme}': (ctx) => getApiCredential(ctx), // the ${fieldOf(scheme)}`),
+    "   }",
+    "",
+    "2. securityResolver:",
+    `   securityResolver: async (tool, ctx) => ({ ${firstField}: await getApiCredential(ctx) })`,
+    "",
+    "3. staticAuth (one credential for every caller):",
+    `   staticAuth: { ${firstField}: process.env.API_CREDENTIAL }`
+  ];
+  if (bearerSchemes.length > 0) {
+    lines.push(
+      "",
+      `4. passthroughCallerToken: true, for the HTTP bearer schemes (${bearerSchemes.join(", ")}) only, and only if the API`,
+      "   accepts the MCP client's own token (same issuer and audience). It sends nothing for other schemes."
+    );
+  }
+  return lines.join("\n");
+}
+function authenticationRequiredError(tool2) {
+  const required = requiredSecurityOf(tool2);
+  const schemes = [...new Map(required.map((security) => [security.scheme, security])).values()];
+  const schemesStr = schemes.map((security) => `${security.scheme} (${security.type})`).join(", ") || "unknown";
+  const first = schemes[0];
+  const firstScheme = first?.scheme ?? "BearerAuth";
+  const field = credentialFieldOf(first);
+  const bearerSchemes = schemes.filter(isBearerScheme).map((security) => security.scheme);
+  const solutions = [
+    `  1. Add authProviderMapper: { '${firstScheme}': (ctx) => getApiCredential(ctx) }, returning the ${field} issued for the API`,
+    `  2. Add securityResolver: async (tool, ctx) => ({ ${field}: await getApiCredential(ctx) })`,
+    `  3. Add staticAuth: { ${field}: process.env.API_CREDENTIAL }`
+  ];
+  if (bearerSchemes.length > 0) {
+    solutions.push(
+      `  4. Set passthroughCallerToken: true, only if the API accepts the MCP client's own token (it fills ${bearerSchemes.join(", ")} only)`
+    );
+  }
+  return new Error(
+    `Authentication required for tool '${tool2.name}': no credential for its security schemes.
+Required security schemes: ${schemesStr}
+Solutions:
+` + solutions.join("\n")
+  );
+}
+function requiredSecurityOf(tool2) {
+  return tool2.mapper.flatMap((mapper) => mapper.security && mapper.required === true ? [mapper.security] : []);
+}
+function authorizationSchemeOf(security) {
+  if (security?.type === "http") return (security.httpScheme ?? "bearer").toLowerCase();
+  if (security?.type === "oauth2" || security?.type === "openIdConnect") return "bearer";
+  return void 0;
+}
+function carriesSchemeParameter(mapper, url, headers) {
+  if (mapper.type === "query") return !!url.searchParams.get(mapper.key);
+  if (mapper.type === "cookie") {
+    return (headers.get("cookie") ?? "").split(";").some((pair) => {
+      const [name, ...value2] = pair.trim().split("=");
+      return name === mapper.key && value2.join("=") !== "";
+    });
+  }
+  if (mapper.type !== "header") return false;
+  const value = headers.get(mapper.key)?.trim();
+  if (!value) return false;
+  const scheme = authorizationSchemeOf(mapper.security);
+  if (!scheme) return true;
+  const space = value.indexOf(" ");
+  return space > 0 && value.slice(0, space).toLowerCase() === scheme && value.slice(space + 1).trim() !== "";
+}
+function assertRequestHasCredential(tool2, url, headers) {
+  const securityMappers = tool2.mapper.filter((mapper) => mapper.security && mapper.required === true);
+  if (securityMappers.length === 0) return;
+  const parsedUrl = new URL(url);
+  if (!securityMappers.some((mapper) => carriesSchemeParameter(mapper, parsedUrl, headers))) {
+    throw authenticationRequiredError(tool2);
+  }
+}
 function validateSecurityConfiguration(tools, options) {
+  const result = validateCredentialSources(tools, options);
+  const schemesInInput = options.securitySchemesInInput ?? [];
+  if (options.generateOptions?.includeSecurityInInput !== true && schemesInInput.length > 0) {
+    result.securityRiskScore = "high";
+    result.warnings.push(
+      `SECURITY WARNING: securitySchemesInInput is enabled. The model provides the credential for security schemes ${schemesInInput.join(", ")} in tool inputs, used when the server supplies none. Credentials may be logged or exposed, and the model chooses whose account a call uses.`
+    );
+  }
+  return result;
+}
+function validateCredentialSources(tools, options) {
   const result = {
     valid: true,
     missingMappings: [],
     warnings: [],
     securityRiskScore: "low"
   };
-  const securitySchemes = extractSecuritySchemes(tools);
+  const securitySchemes = describeSecuritySchemes(tools);
   const includeSecurityInInput = options.generateOptions?.includeSecurityInInput ?? false;
   if (includeSecurityInInput) {
     result.securityRiskScore = "high";
     result.warnings.push(
-      "SECURITY WARNING: includeSecurityInInput is enabled. Users will provide authentication directly in tool inputs. This increases security risk as credentials may be logged or exposed."
+      "SECURITY WARNING: includeSecurityInInput is enabled. Users will provide authentication directly in tool inputs (used for a scheme when the server supplies none). This increases security risk as credentials may be logged or exposed."
     );
     return result;
   }
@@ -318,19 +461,21 @@ function validateSecurityConfiguration(tools, options) {
   }
   const schemesInInput = new Set(options.securitySchemesInInput || []);
   if (options.authProviderMapper || schemesInInput.size > 0) {
-    result.securityRiskScore = schemesInInput.size > 0 ? "medium" : "low";
-    if (schemesInInput.size > 0) {
-      result.warnings.push(
-        `INFO: Per-scheme security control enabled. Schemes in input: ${Array.from(schemesInInput).join(", ")}`
-      );
-    }
+    result.securityRiskScore = "low";
     const passthroughFallback = [];
-    for (const scheme of securitySchemes) {
+    const perRequestHeaders = [];
+    const schemeParameters = schemeParametersOf(tools);
+    for (const [scheme, security] of securitySchemes) {
       if (schemesInInput.has(scheme)) {
         continue;
       }
       if (!options.authProviderMapper?.[scheme]) {
-        if (options.passthroughCallerToken === true) {
+        const headerSource = headerCredentialSource(schemeParameters.get(scheme), options);
+        if (headerSource === "static") {
+          continue;
+        } else if (headerSource === "per-request") {
+          perRequestHeaders.push(scheme);
+        } else if (options.passthroughCallerToken === true && isBearerScheme(security)) {
           passthroughFallback.push(scheme);
         } else {
           result.valid = false;
@@ -343,6 +488,11 @@ function validateSecurityConfiguration(tools, options) {
         `ERROR: Missing auth provider mappings for security schemes: ${result.missingMappings.join(", ")}`
       );
     }
+    if (perRequestHeaders.length > 0) {
+      result.warnings.push(
+        `INFO: Security schemes with no authProviderMapper entry (${perRequestHeaders.join(", ")}) take their credential from headersMapper. An operation that requires only them is refused when headersMapper sets none.`
+      );
+    }
     withPassthroughRisk(result, securitySchemes, options);
     if (passthroughFallback.length > 0) {
       result.warnings.push(
@@ -352,10 +502,17 @@ function validateSecurityConfiguration(tools, options) {
     return result;
   }
   if (securitySchemes.size > 0 && options.passthroughCallerToken !== true) {
-    const schemesStr = Array.from(securitySchemes).join(", ");
+    const schemesStr = Array.from(securitySchemes.keys()).join(", ");
     result.securityRiskScore = "medium";
     result.warnings.push(
-      `SECURITY WARNING: No auth configuration provided, so the adapter has no credentials for the API (security schemes: ${schemesStr}). Operations that require authentication will fail. The MCP client's own token is not forwarded: configure authProviderMapper, securityResolver or staticAuth, or set passthroughCallerToken: true if the API is meant to receive the caller's MCP token.`
+      `SECURITY WARNING: No auth configuration provided, so the adapter has no credentials for the API (security schemes: ${schemesStr}). Operations that require authentication fail unless additionalHeaders or headersMapper sets their credential. The MCP client's own token is not forwarded: configure authProviderMapper, securityResolver or staticAuth, or set passthroughCallerToken: true if the API is meant to receive the caller's MCP token.`
+    );
+  }
+  const unfilled = [...securitySchemes].filter(([, security]) => !isBearerScheme(security)).map(([scheme]) => scheme);
+  if (options.passthroughCallerToken === true && unfilled.length > 0) {
+    result.securityRiskScore = "medium";
+    result.warnings.push(
+      `SECURITY WARNING: The adapter has no credentials for the API for security schemes: ${unfilled.join(", ")}. passthroughCallerToken sends only a bearer token, which these schemes don't use, so operations that require only them fail unless additionalHeaders or headersMapper sets their credential. Configure authProviderMapper, securityResolver or staticAuth for them.`
     );
   }
   return withPassthroughRisk(result, securitySchemes, options);
@@ -364,10 +521,11 @@ function canPassThroughCallerToken(options) {
   return options.passthroughCallerToken === true && !options.securityResolver && !hasStaticAuth(options);
 }
 function withPassthroughRisk(result, securitySchemes, options) {
-  if (securitySchemes.size === 0 || !canPassThroughCallerToken(options)) {
+  const bearerSchemes = [...securitySchemes].filter(([, security]) => isBearerScheme(security));
+  if (bearerSchemes.length === 0 || !canPassThroughCallerToken(options)) {
     return result;
   }
-  const schemesStr = Array.from(securitySchemes).join(", ");
+  const schemesStr = bearerSchemes.map(([scheme]) => scheme).join(", ");
   const when = options.authProviderMapper ? " whenever no authProviderMapper function returns a credential" : "";
   result.securityRiskScore = "high";
   result.warnings.push(
@@ -375,28 +533,63 @@ function withPassthroughRisk(result, securitySchemes, options) {
   );
   return result;
 }
-async function resolveToolSecurity(tool2, ctx, options) {
+async function resolveToolSecurity(tool2, ctx, options, request = {}) {
   const securityResolver = new SecurityResolver();
   const securityContext = await createSecurityContextFromAuth(tool2, ctx, options);
   const hasAuth = securityContext.jwt || securityContext.apiKey || securityContext.basic || securityContext.oauth2Token || securityContext.apiKeys && Object.keys(securityContext.apiKeys).length > 0 || securityContext.customHeaders && Object.keys(securityContext.customHeaders).length > 0;
   const requiresSecurity = tool2.mapper.some((m) => m.security && m.required === true);
-  if (requiresSecurity && !hasAuth) {
-    const requiredSchemes = tool2.mapper.filter((m) => m.security && m.required === true).map((m) => m.security?.scheme ?? "unknown");
-    const uniqueSchemes = [...new Set(requiredSchemes)];
-    const schemesStr = uniqueSchemes.join(", ") || "unknown";
-    const firstScheme = uniqueSchemes[0] || "BearerAuth";
-    throw new Error(
-      `Authentication required for tool '${tool2.name}' but no auth configuration found.
-Required security schemes: ${schemesStr}
-Solutions:
-  1. Add authProviderMapper: { '${firstScheme}': (ctx) => ctx.authInfo.user?.token }
-  2. Add securityResolver: async (tool, ctx) => ({ jwt: await getApiToken(ctx) })
-  3. Add staticAuth: { jwt: process.env.API_TOKEN }
-  4. Set passthroughCallerToken: true, only if the API accepts the MCP client's own token
-  5. Set generateOptions.includeSecurityInInput: true (not recommended for production)`
-    );
+  const fromInput = request.input ? await resolveInputSecurity(tool2, request.input, options, securityResolver) : void 0;
+  const hasInputCredential = !!fromInput && Object.keys(fromInput.headers).length + Object.keys(fromInput.query).length + Object.keys(fromInput.cookies).length > 0;
+  if (requiresSecurity && !hasAuth && !hasInputCredential && !request.deferCredentialCheck) {
+    throw authenticationRequiredError(tool2);
   }
-  return await securityResolver.resolve(tool2.mapper, securityContext);
+  const resolved = await securityResolver.resolve(tool2.mapper, securityContext);
+  if (!fromInput) return resolved;
+  return {
+    ...resolved,
+    headers: { ...fromInput.headers, ...resolved.headers },
+    query: { ...fromInput.query, ...resolved.query },
+    cookies: { ...fromInput.cookies, ...resolved.cookies }
+  };
+}
+function isInputScheme(scheme, options) {
+  return options.generateOptions?.includeSecurityInInput === true || (options.securitySchemesInInput ?? []).includes(scheme);
+}
+function inputCredentialContext(security, value) {
+  const bare = value.replace(/^(?:bearer|basic)\s+/i, "");
+  if (security.type === "apiKey") {
+    return security.apiKeyName ? { apiKeys: { [security.apiKeyName]: value } } : { apiKey: value };
+  }
+  if (security.type === "oauth2" || security.type === "openIdConnect") return { oauth2Token: bare };
+  if (security.type === "http") {
+    const httpScheme = (security.httpScheme ?? "bearer").toLowerCase();
+    if (httpScheme === "bearer") return { jwt: bare };
+    if (httpScheme === "basic") return { basic: bare };
+  }
+  return void 0;
+}
+async function resolveInputSecurity(tool2, input, options, securityResolver) {
+  const resolved = { headers: {}, query: {}, cookies: {} };
+  for (const mapper of tool2.mapper) {
+    const security = mapper.security;
+    if (!security || !isInputScheme(security.scheme, options)) continue;
+    const value = input[mapper.inputKey];
+    if (typeof value !== "string" || value === "") continue;
+    if (/[\r\n\x00\f\v]/.test(value)) {
+      throw new PublicMcpError(
+        `Invalid value for '${mapper.inputKey}': contains control characters (possible header injection attack)`,
+        "INVALID_HEADER_VALUE",
+        400
+      );
+    }
+    const context = inputCredentialContext(security, value);
+    if (!context) continue;
+    const one = await securityResolver.resolve([mapper], createSecurityContext(context));
+    Object.assign(resolved.headers, one.headers);
+    Object.assign(resolved.query, one.query);
+    Object.assign(resolved.cookies, one.cookies);
+  }
+  return resolved;
 }
 
 // libs/adapters/src/openapi/openapi.tool.ts
@@ -645,7 +838,7 @@ function formatZodIssues(issues, prefix) {
 }
 
 // libs/adapters/src/openapi/openapi.utils.ts
-import { PublicMcpError } from "@frontmcp/sdk";
+import { PublicMcpError as PublicMcpError2 } from "@frontmcp/sdk";
 import { trimTrailing, validateBaseUrl } from "@frontmcp/utils";
 function coerceToString(value, paramName, location) {
   if (value === null || value === void 0) {
@@ -703,7 +896,7 @@ function buildRequest(tool2, input, security, baseUrl) {
       case "header": {
         const headerValue = coerceToString(value, mapper.key, "header");
         if (/[\r\n\x00\f\v]/.test(headerValue)) {
-          throw new PublicMcpError(
+          throw new PublicMcpError2(
             `Invalid header value for '${mapper.key}': contains control characters (possible header injection attack)`,
             "INVALID_HEADER_VALUE",
             400
@@ -880,7 +1073,10 @@ function createOpenApiTool(openapiTool, options, logger) {
       inputTransforms,
       transformContext
     );
-    const security = await resolveToolSecurity(openapiTool, ctx, options);
+    const security = await resolveToolSecurity(openapiTool, ctx, options, {
+      input: injectedInput,
+      deferCredentialCheck: true
+    });
     const { url, headers, body: requestBody } = buildRequest(openapiTool, injectedInput, security, options.baseUrl);
     applyAdditionalHeaders(headers, options.additionalHeaders);
     if (options.headersMapper) {
@@ -896,6 +1092,7 @@ function createOpenApiTool(openapiTool, options, logger) {
         throw new Error(`headersMapper failed for tool '${openapiTool.name}': ${errorMessage}`, { cause: err });
       }
     }
+    assertRequestHasCredential(openapiTool, url, headers);
     let finalBody = requestBody;
     if (options.bodyMapper && requestBody) {
       try {
@@ -1180,28 +1377,7 @@ var OpenapiAdapter = class extends DynamicAdapter {
       });
     }
     if (!validation.valid) {
-      throw new Error(
-        `[OpenAPI Adapter: ${this.options.name}] Invalid security configuration.
-Missing auth provider mappings for security schemes: ${validation.missingMappings.join(", ")}
-
-Your OpenAPI spec requires these security schemes, but no auth configuration was provided.
-
-Add one of the following to your adapter configuration:
-
-1. authProviderMapper (recommended):
-   authProviderMapper: {
-` + validation.missingMappings.map((s) => `     '${s}': (authInfo) => authInfo.user?.${s.toLowerCase()}Token,`).join("\n") + `
-   }
-
-2. securityResolver:
-   securityResolver: async (tool, ctx) => ({ jwt: await getApiToken(ctx) })
-
-3. staticAuth:
-   staticAuth: { jwt: process.env.API_TOKEN }
-
-4. Include security in input (NOT recommended for production):
-   generateOptions: { includeSecurityInInput: true }`
-      );
+      throw new Error(formatMissingSecurityMappingsError(this.options.name, openapiTools, validation.missingMappings));
     }
     let transformedTools = openapiTools;
     if (this.options.descriptionMode && this.options.descriptionMode !== "summaryOnly") {