LibreChat/api/server/controllers/mcpApps.js
Dustin Healy 7b27e7941e 🧩 feat: MCP Apps support (#13831)
* feat: add MCP Apps support

* fix: preserve MCP App results and enforce sandbox policy

* fix: bind persisted MCP Apps to their server configuration

* fix: complete MCP Apps runtime integration

* fix: type the optional MCP App binding codec explicitly

* test: provide MCP Apps policy in bridge mocks

* fix: pass admitted App policy to the tool call owner

* fix: align MCP Apps CI contracts

* test: preserve MCP abort reasons in recovery mocks

* fix: preserve MCP compatibility across policy profiles

* test: use profiled MCP catalog generations

* test: expect the standard MCP session profile

* fix: remove the unused MCP abort import

* test: expect profiled MCP fixture arguments

* test: seed profiled MCP manager fixtures

* Fix request-header bearer resolution after canary merge

* Preserve MCP App views across canary message updates

* Document message-owned MCP App placement

* ci: Recheck MCP Apps Against Canary Base

---------

Co-authored-by: Lia <lia@librechat.ai>
(cherry picked from commit a98d40f61c)

Original-PR: https://github.com/LibreChat-AI/LibreChat/pull/13831
2026-10-01 03:46:16 +00:00

76 lines
3.1 KiB
JavaScript

const fs = require('fs');
const path = require('path');
const { logger, getTenantId } = require('@librechat/data-schemas');
const { CacheKeys, resolveMCPAppCspLimits } = require('librechat-data-provider');
const {
createAuthIdentityContext,
createMCPAppsController,
prepareMCPAuthorizationMutation,
} = require('@librechat/api');
const { getMCPManager, getFlowStateManager, getMCPServersRegistry } = require('~/config');
const { getAppConfig, invalidateCachedTools } = require('~/server/services/Config');
const { createOpenIDSessionTokenProvider } = require('~/server/services/OpenIDSessionRefresh');
const {
clearMCPAuthorizationFenceRetry,
persistMCPAuthorizationFenceRetry,
} = require('~/server/services/MCPAuthorizationFenceRetry');
const {
findPluginAuthsByKeys,
findToken,
createToken,
updateToken,
deleteTokens,
} = require('~/models');
const { getLogStores } = require('~/cache');
module.exports = createMCPAppsController({
logger,
sandboxPath: path.resolve(__dirname, '../../../client/public/mcp-sandbox.html'),
sandboxFrameAncestors: process.env.MCP_SANDBOX_FRAME_ANCESTORS,
readSandboxFile: fs.readFileSync,
getManager: getMCPManager,
getFlowManager: () => getFlowStateManager(getLogStores(CacheKeys.FLOWS)),
getAppConfig: (req) =>
getAppConfig({
role: req.user?.role,
userId: req.user?.id,
tenantId: req.user?.tenantId,
failClosed: true,
}),
getSandboxCspLimits: async () => {
const appConfig = await getAppConfig({ baseOnly: true, failClosed: true });
return resolveMCPAppCspLimits(appConfig?.mcpAppSandbox);
},
ensureConfigServers: (mcpConfig) => getMCPServersRegistry().ensureConfigServers(mcpConfig),
getAllServerConfigs: (userId, configServers, role) =>
getMCPServersRegistry().getAllServerConfigs(userId, configServers, role),
recoverServerConfig: (serverName, config, userId) =>
getMCPServersRegistry().recoverServerConfig(serverName, config, userId),
isAppServerConfig: (serverName, config) =>
getMCPServersRegistry().isAppServerConfig(serverName, config),
resolveCachedAppServerConfig: (args) =>
getMCPServersRegistry().resolveCachedAppServerConfig(args),
findPluginAuthsByKeys,
tokenMethods: { findToken, createToken, updateToken, deleteTokens },
createOAuthCredentialsChanging: (req) => {
const recoveryPolicy = req.config?.mcpSettings?.catalogRecovery;
return (scope) =>
prepareMCPAuthorizationMutation(scope, {
invalidateRecoveryGeneration: invalidateCachedTools,
persistPublicationRetry: persistMCPAuthorizationFenceRetry,
clearPublicationRetry: clearMCPAuthorizationFenceRetry,
clearLocalRecovery: (userId, serverName, generation) =>
getMCPManager()?.clearCatalogRecoveryState?.(userId, serverName, generation),
retryDelaysMs: recoveryPolicy?.authorizationFenceRetryMs,
attemptTimeoutMs: recoveryPolicy?.authorizationFenceTimeoutMs,
});
},
createUpstreamTokenProvider: (req, res, user) =>
createOpenIDSessionTokenProvider({
req,
res,
user,
identityContext: createAuthIdentityContext({ user, tenantId: getTenantId() }),
tokenPreference: 'access_token',
}),
});