🏯 fix: Bind MCP Grants to Authorized Agent State and Server Identity (#18233)

* fix: prevent Action writes from expanding MCP access

* fix: fence MCP grant snapshots before Action token cleanup

* fix: reject Action writes after concurrent agent deletion

* fix: enforce MCP grant provenance across saves and server replacement

* test: expect reserved MCP names after server replacement
This commit is contained in:
Danny Avila 2026-11-16 18:42:32 -05:00 • committed by GitHub
parent d36d205c45
commit 39a270ccf0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 730 additions and 37 deletions

View file

@ -823,6 +823,41 @@ describe('MCP Tool Authorization', () => {
expect(agentInDb.mcpServerNames).not.toContain('Workspace');
});
test.each([true, false])(
'does not grant an unindexed Action key with MCP permission: %s',
async (canUse) => {
const tools = ['lookup_action_x_mcp_pay'];
await Agent.updateOne({ id: existingAgentId }, { tools, mcpServerNames: [] });
mockReq.user.id = canUse
? existingAgentAuthorId.toString()
: new mongoose.Types.ObjectId().toString();
mockUserCanUseMCPServers.mockResolvedValue(canUse);
mockReq.params.id = existingAgentId;
mockReq.body = { tools };
await updateAgentHandler(mockReq, mockRes);
expect((await Agent.findOne({ id: existingAgentId })).mcpServerNames).toEqual([]);
},
);
test('rejects grants revoked after controller authorization', async () => {
const db = require('~/models');
mockReq.user.id = existingAgentAuthorId.toString();
mockReq.params.id = existingAgentId;
mockReq.body = { tools: ['existingTool_mcp_authorizedServer'] };
const update = db.updateAgent;
const spy = jest.spyOn(db, 'updateAgent').mockImplementationOnce(async (...args) => {
await Agent.updateOne({ id: existingAgentId }, { tools: [], mcpServerNames: [] });
return update(...args);
});
try {
await updateAgentHandler(mockReq, mockRes);
expect(mockRes.status).toHaveBeenCalledWith(409);
expect((await Agent.findOne({ id: existingAgentId })).mcpServerNames).toEqual([]);
} finally {
spy.mockRestore();
}
});
test('should let persistence derive when an unindexed agent retains MCP tools', async () => {
/** A legacy or partially migrated agent can hold MCP tools with no stored
* mcpServerNames. Pinning the index to [] here would suppress the derivation

View file

@ -1353,17 +1353,16 @@ const updateAgentHandler = async (req, res) => {
}
}
updateData.tools = nextTools;
/** The agent's MCP tools are retained verbatim here, so carry its resolved
* names across too. Left unset when the agent has none stored, so
* `updateAgent` can still derive rather than being pinned to an empty
* index that would strip agent-scoped access. */
if (existingAgent.mcpServerNames?.length) {
updateData.mcpServerNames = existingAgent.mcpServerNames;
}
/** Retained strings alone cannot authorize a previously unindexed server. */
updateData.mcpServerNames = existingAgent.mcpServerNames ?? [];
}
} else if (hasToolUpdate) {
const existingToolSet = new Set(existingTools);
const newMCPTools = requestedMCPTools.filter((t) => !existingToolSet.has(t));
const indexedNames = existingAgent.mcpServerNames ?? [];
const newMCPTools = requestedMCPTools.filter((tool) => {
const [, name] = splitMCPToolKey(tool, indexedNames);
return !existingToolSet.has(tool) || !indexedNames.includes(name);
});
/** Names resolved during authorization of the newly added tools. */
const resolvedServerNames = new Set();
@ -1405,11 +1404,7 @@ const updateAgentHandler = async (req, res) => {
}
}
}
/** Supplying `[]` would pin the index empty and suppress `updateAgent`'s
* derivation, so only assert it when the result is authoritative: either we
* resolved names, or no MCP tool survives and the index genuinely is empty. */
const retainsMCPTools = (updateData.tools ?? []).some(isMCPTool);
if (resolvedServerNames.size > 0 || !retainsMCPTools) {
if (hasToolUpdate) {
updateData.mcpServerNames = Array.from(resolvedServerNames);
}
}
@ -1429,6 +1424,10 @@ const updateAgentHandler = async (req, res) => {
Object.keys(updateData).length > 0
? await db.updateAgent({ id }, updateData, {
updatingUserId: req.user.id,
expectedMCPAccess: {
names: existingAgent.mcpServerNames ?? [],
updatedAt: existingAgent.updatedAt,
},
})
: existingAgent;

View file

@ -0,0 +1,370 @@
const express = require('express');
const mongoose = require('mongoose');
const request = require('supertest');
const mongoSanitize = require('express-mongo-sanitize');
const { MongoMemoryServer } = require('mongodb-memory-server');
const { encryptV2 } = require('@librechat/data-schemas');
const { AccessControlService, MCPServersRegistry } = require('@librechat/api');
const {
PermissionBits,
PrincipalType,
PrincipalModel,
ResourceType,
} = require('librechat-data-provider');
jest.mock('~/models', () => {
const mongoose = require('mongoose');
const { createModels, createMethods } = require('@librechat/data-schemas');
createModels(mongoose);
return createMethods(mongoose);
});
jest.mock('~/server/services/PermissionService', () => {
const mongoose = require('mongoose');
const { AccessControlService } = require('@librechat/api');
const acl = new AccessControlService(mongoose);
return {
checkPermission: (args) => acl.checkPermission(args),
findAccessibleResources: (args) => acl.findAccessibleResources(args),
getResourcePermissionsMap: (args) => acl.getResourcePermissionsMap(args),
};
});
jest.mock('~/server/middleware', () =>
jest.requireActual('~/server/middleware/accessResources/canAccessAgentResource'),
);
jest.mock('~/config', () => ({ getActionFlowStateManager: jest.fn() }));
jest.mock('~/cache', () => {
const values = new Map();
return {
getLogStores: () => ({
get: async (key) => values.get(key),
set: async (key, value) => values.set(key, value),
delete: async (key) => values.delete(key),
}),
};
});
jest.mock('~/server/services/Agents/instructionsPrompt', () => ({
instructionsPromptAccess: { presentForEditor: async ({ agent }) => agent },
}));
const db = require('~/models');
const router = require('./actions');
let mongoServer;
let acl;
let actorId;
let ownerId;
let agent;
let serverName;
let app;
async function grantAgent(agentId, userId) {
await mongoose.models.AclEntry.create({
principalType: PrincipalType.USER,
principalModel: PrincipalModel.USER,
principalId: new mongoose.Types.ObjectId(userId),
resourceType: ResourceType.AGENT,
resourceId: agentId,
permBits: 15,
});
}
const postAction = (domain, agentId = agent.id) =>
request(app)
.post(`/api/agents/actions/${agentId}`)
.send({ functions: [{ function: { name: 'lookup' } }], metadata: { domain } });
beforeAll(async () => {
mongoServer = await MongoMemoryServer.create();
await mongoose.connect(mongoServer.getUri());
await db.seedDefaultRoles();
await db.initializeRoles();
await mongoose.models.Role.updateOne(
{ name: 'USER' },
{ $set: { 'permissions.AGENTS.USE': true, 'permissions.AGENTS.CREATE': true } },
);
acl = new AccessControlService(mongoose);
}, 30000);
afterAll(async () => {
await mongoose.disconnect();
await mongoServer?.stop();
});
beforeEach(async () => {
for (const model of ['Agent', 'MCPServer', 'Action', 'AclEntry', 'User', 'Token']) {
await mongoose.models[model].deleteMany({});
}
actorId = new mongoose.Types.ObjectId().toString();
ownerId = new mongoose.Types.ObjectId().toString();
serverName = 'pay';
await mongoose.models.User.create([
{ _id: actorId, email: `${actorId}@example.test`, role: 'USER', provider: 'local' },
{ _id: ownerId, email: `${ownerId}@example.test`, role: 'USER', provider: 'local' },
]);
agent = await db.createAgent({
id: `agent_${new mongoose.Types.ObjectId()}`,
name: 'Actor agent',
author: actorId,
provider: 'test',
model: 'test-model',
tools: [],
});
await grantAgent(agent._id, actorId);
await mongoose.models.MCPServer.create({
serverName,
author: ownerId,
config: {
type: 'sse',
url: 'https://private.example.test/mcp',
apiKey: {
source: 'admin',
authorization_type: 'bearer',
key: await encryptV2('fixture-owner-secret'),
},
},
});
app = express();
app.use(express.json());
app.use((req, _res, next) => {
Object.defineProperty(req, 'query', { value: req.query, writable: true });
next();
});
app.use(mongoSanitize());
/** Session identity is the fixture; the route's role and resource ACL checks are real. */
app.use((req, _res, next) => {
req.user = { id: actorId, role: 'USER' };
req.config = { filters: {} };
next();
});
app.use('/api/agents/actions', router);
});
describe('Action writes and agent-mediated MCP access', () => {
const oauthMetadata = {
domain: 'https://api.example.test',
auth: {
type: 'oauth',
authorization_url: 'https://1.1.1.1/authorize',
client_url: 'https://1.1.1.1/token',
},
oauth_client_id: 'fixture-client',
oauth_client_secret: 'fixture-secret',
};
const updateOAuthAction = (actionId, metadata = oauthMetadata) =>
request(app)
.post(`/api/agents/actions/${agent.id}`)
.send({
action_id: actionId,
functions: [{ function: { name: 'lookup' } }],
metadata,
});
async function createOAuthAction() {
expect((await updateOAuthAction()).status).toBe(200);
const action = await mongoose.models.Action.findOne({ agent_id: agent.id });
await Promise.all(
[
{ type: 'oauth', identifier: `${actorId}:${action.action_id}` },
{ type: 'oauth_refresh', identifier: `${actorId}:${action.action_id}:refresh` },
].map((token) =>
db.createToken({ ...token, userId: actorId, token: 'fixture-token', expiresIn: 3600 }),
),
);
return action;
}
it('does not grant an unrelated private MCP server through an Action key', async () => {
const privateServer = await mongoose.models.MCPServer.findOne({ serverName });
expect(
await acl.checkPermission({
userId: actorId,
role: 'USER',
resourceType: ResourceType.MCPSERVER,
resourceId: privateServer._id,
requiredPermission: PermissionBits.VIEW,
}),
).toBe(false);
const response = await postAction(`x_mcp_${serverName}`);
expect(response.status).toBe(200);
const stored = await db.getAgent({ id: agent.id });
expect(stored.tools).toContain(`lookup_action_x_mcp_${serverName}`);
const registry = new MCPServersRegistry(mongoose);
expect(await registry.getAllServerConfigs(actorId, undefined, 'USER')).not.toHaveProperty(
serverName,
);
expect(stored.mcpServerNames).toEqual([]);
});
it('preserves an existing MCP grant across Action creation and deletion', async () => {
await db.updateAgent(
{ id: agent.id },
{ tools: [`get_action_version_mcp_${serverName}`], mcpServerNames: [serverName] },
);
const response = await postAction('https://api.example.test');
expect(response.status).toBe(200);
const registry = new MCPServersRegistry(mongoose);
expect(
(await registry.getAllServerConfigs(actorId, undefined, 'USER'))[serverName],
).toMatchObject({ consumeOnly: true });
const action = await mongoose.models.Action.findOne({ agent_id: agent.id });
const deleted = await request(app).delete(
`/api/agents/actions/${agent.id}/${action.action_id}`,
);
expect(deleted.status).toBe(200);
expect((await db.getAgent({ id: agent.id })).mcpServerNames).toEqual([serverName]);
});
it('encodes long Action domains instead of preserving a crafted MCP suffix', async () => {
const response = await postAction('x_mcp_private-payments-server');
expect(response.status).toBe(200);
const stored = await db.getAgent({ id: agent.id });
expect(stored.tools[0]).not.toContain('_mcp_');
expect(stored.mcpServerNames).toEqual([]);
});
it('does not allow an actor to write an Action on an unshared agent', async () => {
const other = await db.createAgent({
id: `agent_${new mongoose.Types.ObjectId()}`,
name: 'Other agent',
author: ownerId,
provider: 'test',
model: 'test-model',
tools: [],
});
await grantAgent(other._id, ownerId);
const response = await postAction(`x_mcp_${serverName}`, other.id);
expect(response.status).toBe(403);
expect(await mongoose.models.Action.countDocuments({ agent_id: other.id })).toBe(0);
});
it('does not save an Action after a conflicting agent write', async () => {
const write = jest.spyOn(db, 'updateAgent').mockRejectedValueOnce({ statusCode: 409 });
try {
const response = await postAction('https://api.example.test');
expect(response.status).toBe(409);
expect(await mongoose.models.Action.countDocuments({ agent_id: agent.id })).toBe(0);
} finally {
write.mockRestore();
}
});
it('preserves OAuth tokens and metadata when the agent write conflicts', async () => {
const action = await createOAuthAction();
const before = await db.getAgent({ id: agent.id });
const write = jest.spyOn(db, 'updateAgent').mockRejectedValueOnce({ statusCode: 409 });
try {
const response = await updateOAuthAction(action.action_id, {
...oauthMetadata,
domain: 'https://new.example.test',
});
expect(response.status).toBe(409);
expect(await mongoose.models.Token.countDocuments({ userId: actorId })).toBe(2);
expect((await db.getAgent({ id: agent.id })).tools).toEqual(before.tools);
expect((await mongoose.models.Action.findById(action._id)).metadata).toEqual(action.metadata);
} finally {
write.mockRestore();
}
});
it('preserves OAuth tokens when the agent disappears before the database write reads it', async () => {
const action = await createOAuthAction();
const updateAgent = db.updateAgent;
const write = jest.spyOn(db, 'updateAgent').mockImplementationOnce(async (...args) => {
await mongoose.models.Agent.deleteOne({ id: agent.id });
return updateAgent(...args);
});
try {
const response = await updateOAuthAction(action.action_id, {
...oauthMetadata,
domain: 'https://new.example.test',
});
expect(response.status).toBe(409);
expect(await mongoose.models.Token.countDocuments({ userId: actorId })).toBe(2);
expect((await mongoose.models.Action.findById(action._id)).metadata).toEqual(action.metadata);
} finally {
write.mockRestore();
}
});
it.each([false, true])(
'invalidates OAuth tokens before publishing metadata only when the target changes: %s',
async (targetChanged) => {
const action = await createOAuthAction();
const metadata = {
...oauthMetadata,
domain: targetChanged ? 'https://new.example.test' : oauthMetadata.domain,
};
const updateAction = db.updateAction;
const write = jest.spyOn(db, 'updateAction').mockImplementation(async (...args) => {
expect(await mongoose.models.Token.countDocuments({ userId: actorId })).toBe(
targetChanged ? 0 : 2,
);
return updateAction(...args);
});
try {
expect((await updateOAuthAction(action.action_id, metadata)).status).toBe(200);
expect(write).toHaveBeenCalledTimes(1);
expect((await mongoose.models.Action.findById(action._id)).metadata.domain).toBe(
metadata.domain,
);
} finally {
write.mockRestore();
}
},
);
it('does not publish new OAuth metadata when token invalidation fails', async () => {
const action = await createOAuthAction();
const remove = jest.spyOn(db, 'deleteTokens').mockRejectedValue(new Error('fixture failure'));
try {
const response = await updateOAuthAction(action.action_id, {
...oauthMetadata,
domain: 'https://new.example.test',
});
expect(response.status).toBe(500);
expect(response.body).toEqual({ message: 'Trouble updating the Agent Action' });
expect(await mongoose.models.Token.countDocuments({ userId: actorId })).toBe(2);
expect((await mongoose.models.Action.findById(action._id)).metadata).toEqual(action.metadata);
} finally {
remove.mockRestore();
}
});
it('does not delete an Action after a conflicting agent write', async () => {
expect((await postAction('https://api.example.test')).status).toBe(200);
const action = await mongoose.models.Action.findOne({ agent_id: agent.id });
const write = jest.spyOn(db, 'updateAgent').mockRejectedValueOnce({ statusCode: 409 });
try {
const response = await request(app).delete(
`/api/agents/actions/${agent.id}/${action.action_id}`,
);
expect(response.status).toBe(409);
expect(await mongoose.models.Action.countDocuments({ agent_id: agent.id })).toBe(1);
} finally {
write.mockRestore();
}
});
});
it.each(['registry', 'legacy'])(
'does not transfer a grant after %s server deletion',
async (mode) => {
await db.updateAgent({ id: agent.id }, { tools: ['lookup_mcp_pay'], mcpServerNames: ['pay'] });
const registry = new MCPServersRegistry(mongoose);
if (mode === 'registry') await registry.removeServer('pay', 'DB', ownerId);
else await mongoose.models.MCPServer.deleteOne({ serverName: 'pay' });
const replacement = await db.createMCPServer({
author: ownerId,
config: { title: 'pay', type: 'sse', url: 'https://replacement.example.test/mcp' },
});
expect(replacement.serverName).not.toBe('pay');
expect(await registry.getAllServerConfigs(actorId, undefined, 'USER')).not.toHaveProperty(
replacement.serverName,
);
},
);

View file

@ -3,6 +3,7 @@ const { nanoid } = require('nanoid');
const { logger } = require('@librechat/data-schemas');
const {
generateCheckAccess,
getAgentActionWriteStatus,
planAgentActionUpdate,
isActionDomainAllowed,
legacyActionDomainEncode,
@ -224,11 +225,6 @@ router.post(
return res.status(400).json({ message: error.message });
}
if (plannedUpdate.deleteOAuthTokens && requestedActionId) {
// Keep the callback URL stable while preventing old OAuth tokens from following a new target.
await deleteActionOAuthTokens(requestedActionId);
}
// Force version update since actions are changing
const updatedAgent = await db.updateAgent(
{ id: agent_id },
@ -236,8 +232,13 @@ router.post(
{
updatingUserId: req.user.id,
forceVersion: true,
preserveMCPAccess: true,
},
);
if (plannedUpdate.deleteOAuthTokens && requestedActionId) {
// A conflict must preserve tokens; invalidate them before publishing the new target.
await deleteActionOAuthTokens(requestedActionId);
}
await attachOwnerContacts([updatedAgent]);
// Only update user field for new actions
@ -277,7 +278,7 @@ router.post(
} catch (error) {
const message = 'Trouble updating the Agent Action';
logger.error(message, error);
res.status(500).json({ message });
res.status(getAgentActionWriteStatus(error)).json({ message });
}
},
);
@ -329,7 +330,7 @@ router.delete(
await db.updateAgent(
{ id: agent_id },
{ tools: updatedTools, actions: updatedActions },
{ updatingUserId: req.user.id, forceVersion: true },
{ updatingUserId: req.user.id, forceVersion: true, preserveMCPAccess: true },
);
const deleted = await db.deleteAction({ actionId: action_id, agentId: agent_id });
if (!deleted) {
@ -342,7 +343,7 @@ router.delete(
} catch (error) {
const message = 'Trouble deleting the Agent Action';
logger.error(message, error);
res.status(500).json({ message });
res.status(getAgentActionWriteStatus(error)).json({ message });
}
},
);

View file

@ -33,6 +33,7 @@ import {
buildActionOAuthTokenDeleteQueries,
legacyActionDomainEncode,
planAgentActionUpdate,
getAgentActionWriteStatus,
} from './update';
const specFor = (serverUrl: string, operationId = 'echoMessage'): string =>
@ -56,6 +57,16 @@ const toolFor = (name: string) => ({
},
});
describe('getAgentActionWriteStatus', () => {
it('maps revision conflicts to 409', () => {
expect(getAgentActionWriteStatus({ statusCode: 409 })).toBe(409);
});
it.each([undefined, null, new Error('database failure'), { statusCode: 403 }])(
'maps unexpected failures to a generic 500',
(error) => expect(getAgentActionWriteStatus(error)).toBe(500),
);
});
const storedServiceMetadata: ActionMetadata = {
domain: 'https://api.example.com',
raw_spec: specFor('https://api.example.com/v1'),

View file

@ -7,6 +7,16 @@ import { mergeAgentActionTools } from './tools';
export const ACTION_CREDENTIAL_REFRESH_MESSAGE =
'Action credentials must be re-entered when changing the domain, OpenAPI server URL, or authentication settings';
/** Map a lost agent revision to a retryable conflict without exposing database errors. */
export function getAgentActionWriteStatus(error: unknown): 409 | 500 {
return error != null &&
typeof error === 'object' &&
'statusCode' in error &&
error.statusCode === 409
? 409
: 500;
}
type StoredActionForUpdate = {
metadata?: ActionMetadata | null;
};

View file

@ -1001,7 +1001,7 @@ describe('ServerConfigsDB', () => {
).not.toContain('another-users-secret');
});
it('does not reuse saved keys when the same server name is recreated at a new URL', async () => {
it('does not reuse the name or saved keys when a deleted server is replaced at a new URL', async () => {
const created = await serverConfigsDB.add('temp-name', config, userId);
const oldField = Object.keys(created.config.customUserVars!)[0];
const savedVars = await saveUserKey(created.serverName, oldField);
@ -1015,7 +1015,7 @@ describe('ServerConfigsDB', () => {
},
userId,
);
expect(recreated.serverName).toBe(created.serverName);
expect(recreated.serverName).not.toBe(created.serverName);
expect(getMissingCustomUserVars(recreated.config, savedVars)).toHaveLength(1);
expect(
JSON.stringify(processMCPEnv({ options: recreated.config, customUserVars: savedVars })),

View file

@ -943,6 +943,152 @@ describe('Agent Methods', () => {
expect(updatedAgent!.mcpServerNames).toEqual(['authorizedServer']);
});
test('an Action write cannot derive MCP access from a constructed tool key', async () => {
const { agentId, authorId } = createTestIds();
await createAgent({
id: agentId,
name: 'Action-only Agent',
provider: 'test',
model: 'test-model',
author: authorId,
tools: [],
});
const updated = await updateAgent(
{ id: agentId },
{ tools: ['lookup_action_x_mcp_private-server'] },
{ preserveMCPAccess: true },
);
expect(updated!.mcpServerNames).toEqual([]);
expect(await methods.getAgentIdsByMCPServerName('private-server')).toEqual([]);
});
test('an Action write preserves existing MCP access without adding a new server', async () => {
const { agentId, authorId } = createTestIds();
const mcpTool = `get_action_version${Constants.mcp_delimiter}Google${Constants.mcp_delimiter}Workspace`;
const server = `Google${Constants.mcp_delimiter}Workspace`;
await createAgent({
id: agentId,
name: 'Mixed Agent',
provider: 'test',
model: 'test-model',
author: authorId,
tools: [mcpTool],
mcpServerNames: [server],
});
const updated = await updateAgent(
{ id: agentId },
{
tools: [mcpTool, 'lookup_action_x_mcp_private-server'],
mcpServerNames: ['private-server'],
},
{ preserveMCPAccess: true },
);
expect(updated!.mcpServerNames).toEqual([server]);
expect(await methods.getAgentIdsByMCPServerName('private-server')).toEqual([]);
});
test('an Action write fails closed for a legacy agent without an MCP index', async () => {
const { agentId, authorId } = createTestIds();
await createAgent({
id: agentId,
name: 'Legacy Action Agent',
provider: 'test',
model: 'test-model',
author: authorId,
tools: [],
});
await Agent.updateOne({ id: agentId }, { $unset: { mcpServerNames: 1 } });
const updated = await updateAgent(
{ id: agentId },
{ tools: ['lookup_action_x_mcp_private-server'] },
{ preserveMCPAccess: true },
);
expect(updated!.mcpServerNames).toEqual([]);
});
test('an Action write drops existing MCP access when its last tool is removed', async () => {
const { agentId, authorId } = createTestIds();
await createAgent({
id: agentId,
name: 'Detached MCP Agent',
provider: 'test',
model: 'test-model',
author: authorId,
tools: ['search_mcp_existing-server'],
mcpServerNames: ['existing-server'],
});
const updated = await updateAgent(
{ id: agentId },
{ tools: ['lookup_action_api---example---com'] },
{ preserveMCPAccess: true },
);
expect(updated!.mcpServerNames).toEqual([]);
});
test.each(['advanced', 'unchanged'])(
'an Action write cannot restore revoked MCP access with an %s timestamp',
async (revision) => {
const { agentId, authorId } = createTestIds();
const tools = ['search_mcp_existing-server'];
await createAgent({
id: agentId,
name: 'Concurrent Action Agent',
provider: 'test',
model: 'test-model',
author: authorId,
tools,
mcpServerNames: ['existing-server'],
});
const originalFindOne = Agent.findOne.bind(Agent);
const read = jest.spyOn(Agent, 'findOne').mockImplementationOnce((...args) => {
const query = originalFindOne(...args);
const originalExec = query.exec.bind(query);
jest.spyOn(query, 'exec').mockImplementationOnce(async () => {
const snapshot = await originalExec();
const snapshotRevision = snapshot?.get('updatedAt');
if (!(snapshotRevision instanceof Date)) {
throw new Error('Agent fixture has no revision');
}
await Agent.updateOne(
{ id: agentId },
{
$set: {
tools: [],
mcpServerNames: [],
updatedAt:
revision === 'unchanged' ? snapshotRevision : new Date(Date.now() + 1000),
},
},
{ timestamps: false },
);
return snapshot;
});
return query;
});
try {
await expect(
updateAgent(
{ id: agentId },
{ tools: [...tools, 'lookup_action_api---example---com'] },
{ preserveMCPAccess: true },
),
).rejects.toThrow('Agent changed during Action update');
} finally {
read.mockRestore();
}
expect((await getAgent({ id: agentId }))!.mcpServerNames).toEqual([]);
},
);
test('should prune nonexistent skill ids from the allowlist on create', async () => {
const { agentId, authorId } = createTestIds();
const realSkill = await mongoose.models.Skill.create({

View file

@ -265,8 +265,8 @@ export interface RevertAgentVersionOptions {
export class AgentRevisionConflictError extends Error {
readonly statusCode = 409;
constructor() {
super('Agent was modified while reverting; reload and try again');
constructor(message = 'Agent was modified while reverting; reload and try again') {
super(message);
this.name = 'AgentRevisionConflictError';
}
}
@ -757,9 +757,13 @@ function extractMCPServerNames(tools: string[] | undefined | null): string[] {
* ambiguous trailing-segment derivation, which cannot tell a config server's
* suffix from a real DB server name.
*/
function rebuildMCPServerNames(tools: string[] | undefined | null, priorNames: string[]): string[] {
function rebuildMCPServerNames(
tools: string[] | undefined | null,
priorNames: string[],
preserveMCPAccess = false,
): string[] {
if (priorNames.length === 0) {
return extractMCPServerNames(tools);
return preserveMCPAccess ? [] : extractMCPServerNames(tools);
}
const retained = new Set<string>();
@ -778,8 +782,10 @@ function rebuildMCPServerNames(tools: string[] | undefined | null, priorNames: s
}
}
for (const name of extractMCPServerNames(unmatched)) {
retained.add(name);
if (!preserveMCPAccess) {
for (const name of extractMCPServerNames(unmatched)) {
retained.add(name);
}
}
return Array.from(retained);
}
@ -1110,6 +1116,9 @@ export function createAgentMethods(
updatingUserId?: string | null;
forceVersion?: boolean;
skipVersioning?: boolean;
/** Action edits may retain existing MCP grants, but cannot derive new grants from keys. */
preserveMCPAccess?: boolean;
expectedMCPAccess?: { names: string[]; updatedAt?: Date };
},
) => Promise<IAgent | null>;
updateAgentAvatar: (params: {
@ -1500,6 +1509,9 @@ export function createAgentMethods(
updatingUserId?: string | null;
forceVersion?: boolean;
skipVersioning?: boolean;
/** Action edits may retain existing MCP grants, but cannot derive new grants from keys. */
preserveMCPAccess?: boolean;
expectedMCPAccess?: { names: string[]; updatedAt?: Date };
} = {},
): Promise<IAgent | null> {
const Agent = mongoose.models.Agent as Model<IAgent>;
@ -1510,6 +1522,11 @@ export function createAgentMethods(
let suppressedVersionEntry = false;
const currentAgent = await Agent.findOne(searchParameter);
if (!currentAgent && (options.preserveMCPAccess || options.expectedMCPAccess)) {
throw new AgentRevisionConflictError(
'Agent changed during Action update; reload and try again',
);
}
const currentRevision = (currentAgent as (IAgent & { updatedAt: Date }) | null)?.updatedAt;
if (currentAgent) {
const currentObject = currentAgent.toObject() as unknown as Record<string, unknown>;
@ -1553,11 +1570,13 @@ export function createAgentMethods(
| string[]
| undefined;
const mcpServerNames =
supplied ??
rebuildMCPServerNames(
(directUpdates as Record<string, unknown>).tools as string[],
(currentAgent.mcpServerNames as string[] | undefined) ?? [],
);
!options.preserveMCPAccess && supplied !== undefined
? supplied
: rebuildMCPServerNames(
(directUpdates as Record<string, unknown>).tools as string[],
(currentAgent.mcpServerNames as string[] | undefined) ?? [],
options.preserveMCPAccess,
);
(directUpdates as Record<string, unknown>).mcpServerNames = mcpServerNames;
updateData.mcpServerNames = mcpServerNames;
}
@ -1677,14 +1696,40 @@ export function createAgentMethods(
}),
);
}
let updateFilter = searchParameter;
if (currentAgent && (nextEnvironmentIds.length > 0 || options.preserveMCPAccess)) {
updateFilter = { ...searchParameter, _id: currentAgent._id, updatedAt: currentRevision };
}
if (currentAgent && options.preserveMCPAccess) {
const priorNames = currentAgent.mcpServerNames ?? [];
/** Timestamps can collide within a millisecond; bind the actual grants being retained. */
updateFilter = {
$and: [
updateFilter,
priorNames.length > 0
? { mcpServerNames: priorNames }
: { $or: [{ mcpServerNames: [] }, { mcpServerNames: null }] },
],
};
}
if (options.expectedMCPAccess) {
const { names, updatedAt } = options.expectedMCPAccess;
updateFilter = {
$and: [
updateFilter,
...(updatedAt ? [{ updatedAt }] : []),
names.length > 0
? { mcpServerNames: names }
: { $or: [{ mcpServerNames: [] }, { mcpServerNames: null }] },
],
};
}
const updatedAgent = await withCodeEnvironmentReferences(
mongoose,
nextEnvironmentIds,
async () =>
(await Agent.findOneAndUpdate(
currentAgent == null || nextEnvironmentIds.length === 0
? searchParameter
: { ...searchParameter, _id: currentAgent._id, updatedAt: currentRevision },
updateFilter,
updateData,
mongoOptions,
).lean()) as IAgent | null,
@ -1700,6 +1745,12 @@ export function createAgentMethods(
},
);
if (currentAgent && (options.preserveMCPAccess || options.expectedMCPAccess) && !updatedAgent) {
throw new AgentRevisionConflictError(
'Agent changed during Action update; reload and try again',
);
}
/** `version` is a response-only field holding the count of `versions`. It is reported
* here so a suppressed entry keeps the shape callers saw before the write was fixed.
* It answers "was a version recorded", never "did the update apply". The two stopped

View file

@ -8,6 +8,7 @@ import {
} from 'librechat-data-provider';
import type { MCPOptions } from 'librechat-data-provider';
import type * as t from '~/types';
import { createMCPNameModel } from '../models/mcpName';
import { createMCPServerMethods } from './mcpServer';
import { createAclEntryMethods } from './aclEntry';
import mcpServerSchema from '~/schema/mcpServer';
@ -22,6 +23,7 @@ let methods: ReturnType<typeof createMCPServerMethods>;
beforeAll(async () => {
mongoServer = await MongoMemoryServer.create();
const mongoUri = mongoServer.getUri();
createMCPNameModel(mongoose);
MCPServer = mongoose.models.MCPServer || mongoose.model('MCPServer', mcpServerSchema);
if (!mongoose.models.AclEntry) {
mongoose.model('AclEntry', aclEntrySchema);
@ -45,6 +47,7 @@ afterAll(async () => {
beforeEach(async () => {
await mongoose.connection.dropDatabase();
await mongoose.models.MCPName.syncIndexes();
});
describe('MCPServer Model Tests', () => {
@ -879,3 +882,16 @@ describe('MCPServer Model Tests', () => {
});
});
});
test.each(['single', 'bulk'])(
'deleted server names remain reserved after %s deletion',
async (mode) => {
const author = new mongoose.Types.ObjectId();
const config: MCPOptions = { title: 'Reserved', type: 'sse', url: 'https://example.test/mcp' };
const first = await methods.createMCPServer({ author, config });
if (mode === 'single') await methods.deleteMCPServer(first.serverName);
else await methods.deleteMCPServersWithAcl([first._id.toString()]);
const next = await methods.createMCPServer({ author, config });
expect(next.serverName).not.toBe(first.serverName);
},
);

View file

@ -137,7 +137,21 @@ export function createMCPServerMethods(
.select('serverName')
.lean<Array<{ serverName: string }>>();
const reservations = await mongoose.models.MCPName.find({
name: { $regex: matchingNamePattern },
})
.select('name')
.lean<Array<{ name: string }>>();
const referenced = await mongoose.models.Agent?.find({
mcpServerNames: { $regex: matchingNamePattern },
})
.select('mcpServerNames')
.lean<Array<{ mcpServerNames: string[] }>>();
const existingNames = new Set([
...(referenced ?? []).flatMap((agent) =>
agent.mcpServerNames.filter((name) => matchingNamePattern.test(name)),
),
...reservations.map((entry) => entry.name),
...existing.map((server) => server.serverName),
...Array.from(reservedServerNames).filter((serverName) =>
matchingNamePattern.test(serverName),
@ -188,6 +202,8 @@ export function createMCPServerMethods(
serverName = `mcp-${nanoid(16)}`;
}
await mongoose.models.MCPName.init();
await mongoose.models.MCPName.create({ name: serverName });
const newServer = await MCPServer.create({
serverName,
normalizedServerName: normalizeServerName(serverName),
@ -367,6 +383,12 @@ export function createMCPServerMethods(
*/
async function deleteMCPServer(serverName: string): Promise<MCPServerDocument | null> {
const MCPServer = mongoose.models.MCPServer as Model<MCPServerDocument>;
await mongoose.models.MCPName.init();
await mongoose.models.MCPName.updateOne(
{ name: serverName },
{ $setOnInsert: { name: serverName } },
{ upsert: true },
);
return await MCPServer.findOneAndDelete({ serverName }).lean<MCPServerDocument>();
}
@ -528,6 +550,19 @@ export function createMCPServerMethods(
}
const MCPServer = mongoose.models.MCPServer as Model<MCPServerDocument>;
const objectIds = ids.map((id) => new mongoose.Types.ObjectId(id));
const servers = await MCPServer.find({ _id: { $in: objectIds } })
.select('serverName')
.lean<Array<{ serverName: string }>>();
await mongoose.models.MCPName.init();
await Promise.all(
servers.map(({ serverName }) =>
mongoose.models.MCPName.updateOne(
{ name: serverName },
{ $setOnInsert: { name: serverName } },
{ upsert: true },
),
),
);
const result = await MCPServer.deleteMany({ _id: { $in: objectIds } });
/** ACL entries are the retry discovery key for sole-owned servers, so they go last. */
await mongoose.models.AclEntry.deleteMany({

View file

@ -43,6 +43,7 @@ import { createConversationModel } from './convo';
import { createToolCallModel } from './toolCall';
import { createAclEntryModel } from './aclEntry';
import { createAuditLogModel } from './auditLog';
import { createMCPNameModel } from './mcpName';
import { createSessionModel } from './session';
import { createPasskeyModel } from './passkey';
import { createBalanceModel } from './balance';
@ -91,6 +92,7 @@ export function createModels(mongoose: typeof import('mongoose')): {
ChannelFeedbackEvent: ReturnType<typeof createChannelFeedbackEventModel>;
ChannelFeedback: ReturnType<typeof createChannelFeedbackModel>;
AgentCategory: ReturnType<typeof createAgentCategoryModel>;
MCPName: ReturnType<typeof createMCPNameModel>;
MCPServer: ReturnType<typeof createMCPServerModel>;
Role: ReturnType<typeof createRoleModel>;
Action: ReturnType<typeof createActionModel>;
@ -156,6 +158,7 @@ export function createModels(mongoose: typeof import('mongoose')): {
ChannelFeedbackEvent: createChannelFeedbackEventModel(mongoose),
ChannelFeedback: createChannelFeedbackModel(mongoose),
AgentCategory: createAgentCategoryModel(mongoose),
MCPName: createMCPNameModel(mongoose),
MCPServer: createMCPServerModel(mongoose),
Role: createRoleModel(mongoose),
Action: createActionModel(mongoose),

View file

@ -0,0 +1,16 @@
import { Schema } from 'mongoose';
import type { Model } from 'mongoose';
import { applyTenantIsolation } from '~/models/plugins/tenantIsolation';
interface MCPName {
name: string;
tenantId?: string;
}
const schema = new Schema<MCPName>({ name: { type: String, required: true, unique: true } });
/** Durable reservations survive server and account deletion. */
export function createMCPNameModel(mongoose: typeof import('mongoose')): Model<MCPName> {
applyTenantIsolation(schema);
return mongoose.models.MCPName || mongoose.model<MCPName>('MCPName', schema);
}