@frontmcp/adapters 1.8.2 → 1.8.4

package/openapi/index.js

@@ -46,7 +46,7 @@ module.exports = __toCommonJS(openapi_exports);
 
 // libs/adapters/src/openapi/openapi.adapter.ts
 var import_mcp_from_openapi3 = require("mcp-from-openapi");
-var import_sdk4 = require("@frontmcp/sdk");
+var import_sdk5 = require("@frontmcp/sdk");
 
 // libs/adapters/src/openapi/openapi-spec-poller.ts
 var import_mcp_from_openapi = require("mcp-from-openapi");
@@ -219,12 +219,13 @@ var OpenApiSpecPoller = class {
 
 // libs/adapters/src/openapi/openapi.security.ts
 var import_mcp_from_openapi2 = require("mcp-from-openapi");
+var import_sdk2 = require("@frontmcp/sdk");
 async function createSecurityContextFromAuth(tool2, ctx, options) {
   if (options.securityResolver) {
     return await options.securityResolver(tool2, ctx);
   }
   if (options.authProviderMapper) {
-    const context = (0, import_mcp_from_openapi2.createSecurityContext)({});
+    const context = {};
     const securitySchemes = /* @__PURE__ */ new Set();
     for (const mapper of tool2.mapper) {
       if (mapper.security?.scheme) {
@@ -273,26 +274,42 @@ 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 });
         }
       }
     }
+    if (hasStaticAuth(options)) {
+      return (0, import_mcp_from_openapi2.createSecurityContext)({ ...options.staticAuth, ...context });
+    }
     const hasAnyAuth = context.jwt || context.apiKey || context.basic || context.oauth2Token;
-    const authToken = ctx.authInfo?.token;
-    if (!hasAnyAuth && authToken) {
-      if (typeof authToken !== "string") {
-        throw new Error(`authInfo.token must be a string, but got: ${typeof authToken}`);
+    if (!hasAnyAuth && options.passthroughCallerToken === true) {
+      const callerToken = getCallerToken(ctx);
+      if (callerToken) {
+        context.jwt = callerToken;
       }
-      context.jwt = authToken;
     }
-    return context;
+    return (0, import_mcp_from_openapi2.createSecurityContext)(context);
   }
-  if (options.staticAuth) {
+  if (hasStaticAuth(options)) {
     return (0, import_mcp_from_openapi2.createSecurityContext)(options.staticAuth);
   }
-  return (0, import_mcp_from_openapi2.createSecurityContext)({
-    jwt: ctx.authInfo?.token
-  });
+  if (options.passthroughCallerToken === true) {
+    return (0, import_mcp_from_openapi2.createSecurityContext)({ jwt: getCallerToken(ctx) });
+  }
+  return (0, import_mcp_from_openapi2.createSecurityContext)({});
+}
+function hasStaticAuth(options) {
+  return !!options.staticAuth && Object.keys(options.staticAuth).length > 0;
+}
+function getCallerToken(ctx) {
+  const authToken = ctx.authInfo?.token;
+  if (authToken === void 0 || authToken === null || authToken === "") {
+    return void 0;
+  }
+  if (typeof authToken !== "string") {
+    throw new Error(`authInfo.token must be a string, but got: ${typeof authToken}`);
+  }
+  return authToken;
 }
 function extractSecuritySchemes(tools) {
   const schemes = /* @__PURE__ */ new Set();
@@ -305,19 +322,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;
   }
@@ -328,28 +484,35 @@ function validateSecurityConfiguration(tools, options) {
     );
     return result;
   }
-  if (options.staticAuth && Object.keys(options.staticAuth).length > 0) {
+  if (hasStaticAuth(options)) {
     result.securityRiskScore = "medium";
     result.warnings.push(
       "SECURITY INFO: Using staticAuth with hardcoded credentials. Ensure credentials are stored securely (environment variables, secrets manager)."
     );
-    return result;
+    return withPassthroughRisk(result, securitySchemes, 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(", ")}`
-      );
-    }
-    for (const scheme of securitySchemes) {
+    result.securityRiskScore = "low";
+    const passthroughFallback = [];
+    const perRequestHeaders = [];
+    const schemeParameters = schemeParametersOf(tools);
+    for (const [scheme, security] of securitySchemes) {
       if (schemesInInput.has(scheme)) {
         continue;
       }
       if (!options.authProviderMapper?.[scheme]) {
-        result.valid = false;
-        result.missingMappings.push(scheme);
+        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;
+          result.missingMappings.push(scheme);
+        }
       }
     }
     if (!result.valid) {
@@ -357,47 +520,113 @@ 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(
+        `SECURITY WARNING: Security schemes with no authProviderMapper entry (${passthroughFallback.join(", ")}) get the MCP client's own token, because passthroughCallerToken is enabled.`
+      );
+    }
     return result;
   }
-  if (securitySchemes.size > 0) {
+  if (securitySchemes.size > 0 && options.passthroughCallerToken !== true) {
+    const schemesStr = Array.from(securitySchemes.keys()).join(", ");
     result.securityRiskScore = "medium";
     result.warnings.push(
-      `INFO: No auth configuration provided. Using default ctx.authInfo.token for all security schemes: ${Array.from(
-        securitySchemes
-      ).join(", ")}`
+      `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(
-      "RECOMMENDATION: For multiple auth providers, use authProviderMapper or securityResolver to map each security scheme to the correct auth provider."
+      `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);
+}
+function canPassThroughCallerToken(options) {
+  return options.passthroughCallerToken === true && !options.securityResolver && !hasStaticAuth(options);
+}
+function withPassthroughRisk(result, securitySchemes, options) {
+  const bearerSchemes = [...securitySchemes].filter(([, security]) => isBearerScheme(security));
+  if (bearerSchemes.length === 0 || !canPassThroughCallerToken(options)) {
+    return result;
+  }
+  const schemesStr = bearerSchemes.map(([scheme]) => scheme).join(", ");
+  const when = options.authProviderMapper ? " whenever no authProviderMapper function returns a credential" : "";
+  result.securityRiskScore = "high";
+  result.warnings.push(
+    `SECURITY WARNING: passthroughCallerToken is enabled. The MCP client's own token (ctx.authInfo.token) is sent to the API${when} for security schemes: ${schemesStr}. Only use this when the API accepts tokens issued for this MCP server.`
+  );
   return result;
 }
-async function resolveToolSecurity(tool2, ctx, options) {
+async function resolveToolSecurity(tool2, ctx, options, request = {}) {
   const securityResolver = new import_mcp_from_openapi2.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: (tool, ctx) => ({ jwt: ctx.authInfo.token })
-  3. Add staticAuth: { jwt: process.env.API_TOKEN }
-  4. 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 import_sdk2.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], (0, import_mcp_from_openapi2.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
 var import_lazy_zod2 = require("@frontmcp/lazy-zod");
-var import_sdk3 = require("@frontmcp/sdk");
+var import_sdk4 = require("@frontmcp/sdk");
 var import_utils3 = require("@frontmcp/utils");
 
 // libs/adapters/src/openapi/openapi.frontmcp-schema.ts
@@ -641,7 +870,7 @@ function formatZodIssues(issues, prefix) {
 }
 
 // libs/adapters/src/openapi/openapi.utils.ts
-var import_sdk2 = require("@frontmcp/sdk");
+var import_sdk3 = require("@frontmcp/sdk");
 var import_utils2 = require("@frontmcp/utils");
 function coerceToString(value, paramName, location) {
   if (value === null || value === void 0) {
@@ -699,7 +928,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 import_sdk2.PublicMcpError(
+          throw new import_sdk3.PublicMcpError(
             `Invalid header value for '${mapper.key}': contains control characters (possible header injection attack)`,
             "INVALID_HEADER_VALUE",
             400
@@ -864,7 +1093,7 @@ function createOpenApiTool(openapiTool, options, logger) {
   if (toolTransform.ui) {
     toolMetadata["ui"] = toolTransform.ui;
   }
-  return (0, import_sdk3.tool)(toolMetadata)(async (input, toolCtx) => {
+  return (0, import_sdk4.tool)(toolMetadata)(async (input, toolCtx) => {
     const ctx = toolCtx.context;
     const transformContext = {
       ctx,
@@ -876,7 +1105,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) {
@@ -892,6 +1124,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 {
@@ -1113,7 +1346,7 @@ function createConsoleLogger(prefix) {
     child: (childPrefix) => createConsoleLogger(`${prefix}:${childPrefix}`)
   };
 }
-var OpenapiAdapter = class extends import_sdk4.DynamicAdapter {
+var OpenapiAdapter = class extends import_sdk5.DynamicAdapter {
   generator;
   logger;
   options;
@@ -1176,28 +1409,7 @@ var OpenapiAdapter = class extends import_sdk4.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: (tool, authInfo) => ({ jwt: authInfo.token })
-
-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") {
@@ -1851,7 +2063,7 @@ ${this.formatSchemaAsSummary(schema)}`;
   }
 };
 OpenapiAdapter = __decorateClass([
-  (0, import_sdk4.Adapter)({
+  (0, import_sdk5.Adapter)({
     name: "openapi",
     description: "OpenAPI adapter for FrontMCP - Automatically generates MCP tools from OpenAPI specifications"
   })

package/openapi/openapi.adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.adapter.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,cAAc,EAAE,KAAK,uBAAuB,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAK3G,OAAO,EAIL,KAAK,qBAAqB,EAQ3B,MAAM,iBAAiB,CAAC;AAwBzB,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,cAAc,CAAC,qBAAqB,CAAC;IAC/E,OAAO,CAAC,SAAS,CAAC,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAiB;IACxB,OAAO,EAAE,qBAAqB,CAAC;IACtC,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,eAAe,CAA0D;IACjF,OAAO,CAAC,YAAY,CAAoC;gBAE5C,OAAO,EAAE,qBAAqB;IAc1C;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIjC,KAAK,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAuI/C;;;OAGG;IACH;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;YAId,mBAAmB;IA4BjC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA0C5B;;;OAGG;IACH,OAAO,CAAC,cAAc;IAMtB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IA6D7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAsC3B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAoD5B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA2D7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA0C7B;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAkBnC;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAoBpC;;;;OAIG;YACW,wBAAwB;IAiFtC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;;OAGG;IACH,OAAO,CAAC,0CAA0C;IA+BlD;;;OAGG;IACH,OAAO,CAAC,2CAA2C;IAyCnD;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,GAAG,MAAM,IAAI;IAO3E;;;;OAIG;IACH,YAAY,IAAI,IAAI;IA6CpB;;OAEG;IACH,WAAW,IAAI,IAAI;CAOpB"}
+{"version":3,"file":"openapi.adapter.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,cAAc,EAAE,KAAK,uBAAuB,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAK3G,OAAO,EAIL,KAAK,qBAAqB,EAQ3B,MAAM,iBAAiB,CAAC;AAwBzB,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,cAAc,CAAC,qBAAqB,CAAC;IAC/E,OAAO,CAAC,SAAS,CAAC,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAiB;IACxB,OAAO,EAAE,qBAAqB,CAAC;IACtC,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,eAAe,CAA0D;IACjF,OAAO,CAAC,YAAY,CAAoC;gBAE5C,OAAO,EAAE,qBAAqB;IAc1C;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIjC,KAAK,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAsH/C;;;OAGG;IACH;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;YAId,mBAAmB;IA4BjC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA0C5B;;;OAGG;IACH,OAAO,CAAC,cAAc;IAMtB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IA6D7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAsC3B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAoD5B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA2D7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA0C7B;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAkBnC;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAoBpC;;;;OAIG;YACW,wBAAwB;IAiFtC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;;OAGG;IACH,OAAO,CAAC,0CAA0C;IA+BlD;;;OAGG;IACH,OAAO,CAAC,2CAA2C;IAyCnD;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,GAAG,MAAM,IAAI;IAO3E;;;;OAIG;IACH,YAAY,IAAI,IAAI;IA6CpB;;OAEG;IACH,WAAW,IAAI,IAAI;CAOpB"}

package/openapi/openapi.security.d.ts

@@ -1,5 +1,5 @@
-import { type McpOpenAPITool, type SecurityContext } from 'mcp-from-openapi';
-import type { FrontMcpContext } from '@frontmcp/sdk';
+import { type McpOpenAPITool, type ResolvedSecurity, type SecurityContext } from 'mcp-from-openapi';
+import { type FrontMcpContext } from '@frontmcp/sdk';
 import type { OpenApiAdapterOptions } from './openapi.types';
 /**
  * Security scheme information extracted from OpenAPI spec
@@ -28,7 +28,7 @@ export interface SecurityValidationResult {
  * @param options - Adapter options with auth configuration
  * @returns Security context for resolver
  */
-export declare function createSecurityContextFromAuth(tool: McpOpenAPITool, ctx: FrontMcpContext, options: Pick<OpenApiAdapterOptions, 'securityResolver' | 'authProviderMapper' | 'staticAuth'>): Promise<SecurityContext>;
+export declare function createSecurityContextFromAuth(tool: McpOpenAPITool, ctx: FrontMcpContext, options: Pick<OpenApiAdapterOptions, 'securityResolver' | 'authProviderMapper' | 'staticAuth' | 'passthroughCallerToken'>): Promise<SecurityContext>;
 /**
  * Extract all security schemes used by a set of tools
  *
@@ -36,6 +36,26 @@ export declare function createSecurityContextFromAuth(tool: McpOpenAPITool, ctx:
  * @returns Set of security scheme names
  */
 export declare function extractSecuritySchemes(tools: McpOpenAPITool[]): Set<string>;
+/**
+ * The startup error for security schemes that no credential option covers, with a suggestion for
+ * each: an `authProviderMapper` function (it receives the request context), `securityResolver`,
+ * `staticAuth`, and `passthroughCallerToken` only for the HTTP bearer schemes it can fill.
+ */
+export declare function formatMissingSecurityMappingsError(adapterName: string, tools: McpOpenAPITool[], missingMappings: string[]): string;
+/**
+ * Refuse a request, before it is sent, when its operation requires authentication and the request
+ * carries no credential for any of the operation's security schemes.
+ *
+ * `resolveToolSecurity` only checks that some credential source answered. That answer may not fit
+ * the operation: `passthroughCallerToken` and a `staticAuth` holding only `jwt` fill the bearer
+ * token, which an API key, basic, OAuth2 or OpenID Connect scheme never reads, so the request
+ * would go out with no credential at all. The request is checked as built, after `additionalHeaders`
+ * and `headersMapper`, so a key those set counts. An OpenAPI spec may accept any one of an
+ * operation's schemes, so one is enough.
+ *
+ * @throws Error `Authentication required for tool '…'`
+ */
+export declare function assertRequestHasCredential(tool: McpOpenAPITool, url: string, headers: Headers): void;
 /**
  * Validate security configuration against OpenAPI security requirements
  *
@@ -43,15 +63,34 @@ export declare function extractSecuritySchemes(tools: McpOpenAPITool[]): Set<str
  * @param options - Adapter options
  * @returns Validation result with errors and warnings
  */
-export declare function validateSecurityConfiguration(tools: McpOpenAPITool[], options: Pick<OpenApiAdapterOptions, 'securityResolver' | 'authProviderMapper' | 'staticAuth' | 'generateOptions' | 'securitySchemesInInput'>): SecurityValidationResult;
+export declare function validateSecurityConfiguration(tools: McpOpenAPITool[], options: Pick<OpenApiAdapterOptions, 'securityResolver' | 'authProviderMapper' | 'staticAuth' | 'generateOptions' | 'securitySchemesInInput' | 'passthroughCallerToken' | 'additionalHeaders' | 'headersMapper'>): SecurityValidationResult;
+/**
+ * How `resolveToolSecurity` is used for one call.
+ */
+export interface ResolveToolSecurityRequest {
+    /**
+     * The tool's input: the credentials it carries for the schemes `generateOptions.includeSecurityInInput`
+     * or `securitySchemesInInput` put there are resolved too, and used for a scheme only when the
+     * server supplies none for it (a credential option here, `additionalHeaders` or `headersMapper`
+     * after): the model chooses them, so a prompt injection could otherwise swap in another account.
+     */
+    input?: Record<string, unknown>;
+    /**
+     * The caller checks the request it builds with `assertRequestHasCredential` (after
+     * `additionalHeaders` and `headersMapper`), so an operation is not refused here for a context with
+     * no credential: a header those set, or an input credential, may still supply it.
+     */
+    deferCredentialCheck?: boolean;
+}
 /**
  * Resolve security for an OpenAPI tool with validation
  *
  * @param tool - OpenAPI tool with mapper
  * @param ctx - FrontMCP request context with authInfo, sessionId, traceId, etc.
  * @param options - Adapter options with auth configuration
+ * @param request - The call's input, and whether the caller checks the built request itself
  * @returns Resolved security (headers, query params, etc.)
  * @throws Error if security cannot be resolved
  */
-export declare function resolveToolSecurity(tool: McpOpenAPITool, ctx: FrontMcpContext, options: Pick<OpenApiAdapterOptions, 'securityResolver' | 'authProviderMapper' | 'staticAuth'>): Promise<import("mcp-from-openapi").ResolvedSecurity>;
+export declare function resolveToolSecurity(tool: McpOpenAPITool, ctx: FrontMcpContext, options: Pick<OpenApiAdapterOptions, 'securityResolver' | 'authProviderMapper' | 'staticAuth' | 'passthroughCallerToken' | 'generateOptions' | 'securitySchemesInInput'>, request?: ResolveToolSecurityRequest): Promise<ResolvedSecurity>;
 //# sourceMappingURL=openapi.security.d.ts.map

package/openapi/openapi.security.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.security.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.security.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACtH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,OAAO,CAAC;IACf,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC9C;AAED;;;;;;;GAOG;AACH,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,YAAY,CAAC,GAC7F,OAAO,CAAC,eAAe,CAAC,CA0G1B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAY3E;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,IAAI,CACX,qBAAqB,EACrB,kBAAkB,GAAG,oBAAoB,GAAG,YAAY,GAAG,iBAAiB,GAAG,wBAAwB,CACxG,GACA,wBAAwB,CA6F1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,YAAY,CAAC,wDAwC/F"}
+{"version":3,"file":"openapi.security.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.security.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAEnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAErE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,OAAO,CAAC;IACf,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC9C;AAED;;;;;;;GAOG;AACH,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,IAAI,CACX,qBAAqB,EACrB,kBAAkB,GAAG,oBAAoB,GAAG,YAAY,GAAG,wBAAwB,CACpF,GACA,OAAO,CAAC,eAAe,CAAC,CA+G1B;AAwBD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAY3E;AA8DD;;;;GAIG;AACH,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,cAAc,EAAE,EACvB,eAAe,EAAE,MAAM,EAAE,GACxB,MAAM,CAgCR;AAqED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAOpG;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,IAAI,CACX,qBAAqB,EACnB,kBAAkB,GAClB,oBAAoB,GACpB,YAAY,GACZ,iBAAiB,GACjB,wBAAwB,GACxB,wBAAwB,GACxB,mBAAmB,GACnB,eAAe,CAClB,GACA,wBAAwB,CAY1B;AAkLD;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,IAAI,CACX,qBAAqB,EACnB,kBAAkB,GAClB,oBAAoB,GACpB,YAAY,GACZ,wBAAwB,GACxB,iBAAiB,GACjB,wBAAwB,CAC3B,EACD,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,gBAAgB,CAAC,CA8C3B"}

package/openapi/openapi.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.tool.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAK1D,OAAO,KAAK,EAIV,qBAAqB,EAEtB,MAAM,iBAAiB,CAAC;AAMzB;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,cAAc,cA8SpH"}
+{"version":3,"file":"openapi.tool.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAK1D,OAAO,KAAK,EAIV,qBAAqB,EAEtB,MAAM,iBAAiB,CAAC;AAMzB;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,cAAc,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,cAAc,cAwTpH"}

package/openapi/openapi.types.d.ts

@@ -638,6 +638,9 @@ interface BaseOptions {
      * Static authentication configuration when not using dynamic auth from context.
      * Useful for server-to-server APIs with static credentials.
      *
+     * With an `authProviderMapper`, it fills every credential no mapper function returned (a mapped
+     * value wins), so the caller's token (`passthroughCallerToken`) is never used alongside it.
+     *
      * @example
      * ```typescript
      * staticAuth: {
@@ -647,6 +650,22 @@ interface BaseOptions {
      * ```
      */
     staticAuth?: Partial<SecurityContext>;
+    /**
+     * Forward the MCP client's own bearer token (`ctx.authInfo.token`) to the API when no other
+     * credential source (`authProviderMapper`, `staticAuth`) supplied a credential.
+     *
+     * Off by default: the caller's token was issued for this MCP server, and sending it to another
+     * service is token passthrough, which the MCP specification forbids. Without this option an
+     * operation that requires authentication fails when the adapter has no credential for it.
+     * Enable it only when the API is meant to accept the same token (same issuer and audience).
+     * The token is sent as the bearer token (`jwt`), so it fills only HTTP bearer schemes: it also
+     * covers such a scheme when it has no `authProviderMapper` entry (otherwise refused at startup),
+     * and an operation whose schemes are all of other types (API key, basic, OAuth2, OpenID
+     * Connect) still fails with `Authentication required for tool '…'`.
+     *
+     * @default false
+     */
+    passthroughCallerToken?: boolean;
     /**
      * Options for loading the OpenAPI specification.
      *