Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import { Keyv } from 'keyv';
import { AgentCapabilities, Permissions, PermissionTypes } from 'librechat-data-provider';
import type {
ScheduleMCPConsentStorage,
ScheduleConsentSnapshot,
IUser,
IRole,
AppConfig,
} from '@librechat/data-schemas';
import type { ScheduledMCPIdentity, ScheduledMCPTarget } from 'librechat-data-provider';
import type {
ScheduledMCPBearerResult,
ScheduledMCPResourceBearerResolver,
} from './authorization/contract';
import type { MCPOAuthTokens } from '~/mcp/oauth/types';
import type { ParsedServerConfig } from '~/mcp/types';
import {
createScheduledMCPBearerHost,
createScheduledMCPBearerHeaderResolver,
createMCPPermissionDeniedError,
attachScheduledMCPBearer,
resolveScheduledMCPBearerConfig,
prepareScheduledMCPBearer,
bindScheduledMCPBearerInvocation,
rejectScheduledMCPBearer,
} from './bearer';
import {
createMCPRequestContext,
cleanupMCPRequestContext,
quiesceMCPRequestContext,
} from '~/mcp/request';
import { createScheduleMCPExecution, bindScheduledMCPInvocation } from './authorization/execution';
import { MockKeyv, createOAuthMCPServer } from '~/mcp/__tests__/helpers/oauthTestServer';
import { getScheduledMCPConfigurationRevision } from './authorization/configuration';
import { getScheduledMCPToolDefinitionDigest } from './authorization/policy';
import { createScheduleMCPConsentService } from './authorization/service';
import { MCPServersRegistry } from '~/mcp/registry/MCPServersRegistry';
import { MCPConnectionFactory } from '~/mcp/MCPConnectionFactory';
import { restoreScheduledTokenContext } from './context';
import { createScheduleMCPPreflight } from './mcp';
import { FlowStateManager } from '~/flow/manager';
import { MCPConnection } from '~/mcp/connection';
import { MCPManager } from '~/mcp/MCPManager';
const user = { id: 'owner', tenantId: 'tenant', role: 'USER' } as IUser;
const identity: ScheduledMCPIdentity = {
scheduleId: 'schedule',
ownerId: user.id,
tenantId: 'tenant',
agentId: 'root',
invocationMode: 'delegated',
};
const config: ParsedServerConfig = {
type: 'streamable-http',
url: 'https://resource.test/mcp',
source: 'yaml',
headers: { Authorization: 'Bearer {{LIBRECHAT_OPENID_ACCESS_TOKEN}}' },
};
async function bearerFixture(serverConfig = config) {
let time = Date.now();
let allowed = true;
let policy = true;
const target: ScheduledMCPTarget = {
resource: {
serverName: 'Files',
url: serverConfig.url!,
credentialMode: 'resource_bearer',
issuer: 'https://issuer.test/',
audience: 'files',
scopes: ['read'],
configurationRevision: '',
},
permittedTools: [
{ agentId: 'root', tools: ['echo'] },
{ agentId: 'child', tools: ['echo'] },
],
policyRevision: 'read-only-policy',
};
target.resource.configurationRevision = getScheduledMCPConfigurationRevision(
serverConfig,
target.resource,
);
const snapshot: ScheduleConsentSnapshot = {
agentId: 'root',
enabled: true,
configRevision: 0,
enrollment: null,
};
const storage: ScheduleMCPConsentStorage = {
readScheduleMCPConsent: async () => structuredClone(snapshot),
confirmScheduleMCPConsent: async (input) => {
snapshot.enrollment = structuredClone(input.enrollment);
return true;
},
revokeScheduleMCPConsent: async () => {
for (const c of snapshot.enrollment?.consents ?? []) c.revokedAtMs = time;
return true;
},
admitScheduleMCPConsent: async (input) =>
(input.requireEnabled === false || snapshot.enabled) &&
snapshot.configRevision === input.expectedConfigRevision &&
snapshot.enrollment?.revision === input.revision &&
snapshot.enrollment.consents.every(
(c) => c.revokedAtMs == null && c.absoluteExpiresAtMs > time,
),
};
const resolveEnrollment = jest.fn(async () => [structuredClone(target)]);
const consent = createScheduleMCPConsentService({
storage,
resolveEnrollment,
now: () => time,
canUse: async () => allowed,
getLimits: async () => ({ enabled: true, maxLifetimeHours: 1 }),
checkToolPolicy: async (request) =>
policy && request.selection.tools.every((tool) => tool === 'echo'),
});
const offer = await consent.view(identity);
await consent.confirm(identity, {
expectedRevision: null,
offerDigest: offer.offer!.digest,
lifetimeHours: 1,
});
const resolveBearer = jest.fn(
async (
_request: Parameters<ScheduledMCPResourceBearerResolver>[0],
_options: Parameters<ScheduledMCPResourceBearerResolver>[1],
): Promise<ScheduledMCPBearerResult> => ({
state: 'ready',
accessToken: 'resource-only',
expiresAtMs: time + 60_000,
issuer: target.resource.issuer!,
audience: target.resource.audience!,
resourceUrl: target.resource.url,
}),
);
const host = createScheduledMCPBearerHost({
authority: consent.authority,
resolveEnrollment,
resolveBearer,
now: () => time,
});
const context = createMCPRequestContext();
attachScheduledMCPBearer(context, identity, host);
const input = { context, config: serverConfig, user, serverName: 'Files' };
const call = (agentId = 'root', tools = ['echo']) =>
resolveScheduledMCPBearerConfig({ ...input, selection: { agentId, tools } });
return {
host,
context,
input,
call,
consent,
storage,
resolveBearer,
resolveEnrollment,
snapshot,
target,
advance: (ms: number) => {
time += ms;
},
deny: () => {
allowed = false;
},
denyPolicy: () => {
policy = false;
},
revoke: () => consent.revoke(identity, snapshot.enrollment!.revision),
};
}
it('defaults unattended direct-bearer connections to denial without contacting a browser or provider', async () => {
const context = createMCPRequestContext();
attachScheduledMCPBearer(context, identity);
await expect(
resolveScheduledMCPBearerConfig({ context, config, user, serverName: 'Files' }),
).rejects.toMatchObject({ failure: { reason: 'provider_missing' } });
});
it('can probe activation and owner-manual use while disabled, but never automatic invocation', async () => {
const f = await bearerFixture();
f.snapshot.enabled = false;
const activation = createMCPRequestContext();
// Readiness uses activation to validate re-enable before the write enables the row.
attachScheduledMCPBearer(activation, identity, f.host, 'activation');
await expect(
resolveScheduledMCPBearerConfig({ ...f.input, context: activation }),
).resolves.toMatchObject({ headers: { Authorization: 'Bearer resource-only' } });
expect(f.resolveBearer).toHaveBeenCalledWith(
expect.objectContaining({ stage: 'activation' }),
expect.anything(),
);
const manual = createMCPRequestContext();
attachScheduledMCPBearer(manual, identity, f.host, 'invoke', undefined, { manual: true });
await expect(
resolveScheduledMCPBearerConfig({ ...f.input, context: manual }),
).resolves.toBeDefined();
expect(f.resolveBearer).toHaveBeenLastCalledWith(
expect.objectContaining({ stage: 'mint', manual: true }),
expect.anything(),
);
f.advance(60_001);
await expect(
resolveScheduledMCPBearerConfig({ ...f.input, context: manual }),
).resolves.toBeDefined();
await expect(f.call()).rejects.toMatchObject({ failure: { reason: 'binding_mismatch' } });
const execution = createScheduleMCPExecution({
storage: f.storage,
loadAuthorization: async () => ({ authority: f.consent.authority }),
});
for (const allowed of [true, false]) {
const resumed = createMCPRequestContext();
await execution.attach(resumed, identity, 'resume', true, { manual: allowed });
prepareScheduledMCPBearer({
req: { user, _isScheduledFire: true, body: { manual: !allowed, agent_id: 'untrusted' } },
context: resumed,
host: f.host,
});
const attempt = resolveScheduledMCPBearerConfig({ ...f.input, context: resumed });
if (allowed) {
await expect(attempt).resolves.toBeDefined();
expect(f.resolveBearer).toHaveBeenLastCalledWith(
expect.objectContaining({ manual: true, identity }),
expect.anything(),
);
} else await expect(attempt).rejects.toMatchObject({ failure: { reason: 'binding_mismatch' } });
}
await f.revoke();
await expect(
resolveScheduledMCPBearerConfig({ ...f.input, context: manual }),
).rejects.toMatchObject({ failure: { reason: 'consent_revoked' } });
});
it('checks authority on every cache hit while minting once for root, child and preflight use', async () => {
const f = await bearerFixture();
await expect(resolveScheduledMCPBearerConfig(f.input)).resolves.toMatchObject({
headers: { Authorization: 'Bearer resource-only' },
});
await f.call('root');
await f.call('child');
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
f.deny();
await expect(f.call()).rejects.toMatchObject({ failure: { reason: 'rbac_denied' } });
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
});
it('renews after synthetic expiry without a session, retaining no login refresh credentials', async () => {
const f = await bearerFixture();
await f.call();
f.advance(60_001);
await f.call();
expect(f.resolveBearer).toHaveBeenCalledTimes(2);
expect(f.resolveBearer.mock.calls[0]).toEqual([
expect.objectContaining({ stage: 'mint', identity, resource: f.target.resource }),
{ signal: expect.any(AbortSignal) },
]);
});
it.each(['revoke', 'expiry', 'policy', 'root', 'revision', 'resource'] as const)(
'rejects %s after credential admission',
async (mutation) => {
const f = await bearerFixture();
await f.call();
if (mutation === 'revoke') await f.revoke();
if (mutation === 'expiry') f.advance(3600_001);
if (mutation === 'policy') f.denyPolicy();
if (mutation === 'root') f.snapshot.agentId = 'other';
if (mutation === 'revision') f.snapshot.configRevision++;
if (mutation === 'resource') f.target.resource.url = 'https://other.test/mcp';
await expect(f.call()).rejects.toMatchObject({ failure: { automaticReplay: false } });
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
},
);
it('denies changed runtime routing, unknown child, mutation, and cross-tenant user before minting', async () => {
const f = await bearerFixture();
await expect(f.call('unknown')).rejects.toMatchObject({
failure: { reason: 'tool_policy_denied' },
});
await expect(f.call('root', ['write'])).rejects.toMatchObject({
failure: { reason: 'tool_policy_denied' },
});
await expect(
resolveScheduledMCPBearerConfig({ ...f.input, user: { ...user, tenantId: 'other' } }),
).rejects.toMatchObject({ failure: { reason: 'binding_mismatch' } });
await expect(
resolveScheduledMCPBearerConfig({
...f.input,
config: { ...config, url: 'https://other.test/mcp' },
}),
).rejects.toMatchObject({ failure: { reason: 'binding_mismatch' } });
expect(f.resolveBearer).not.toHaveBeenCalled();
});
it('refuses tokens with changed issuer, audience, destination, expiry or header control bytes', async () => {
for (const change of [
{ issuer: 'https://bad.test/' },
{ audience: 'other' },
{ resourceUrl: 'https://other.test/mcp' },
{ expiresAtMs: 0 },
{ accessToken: 'secret\r\nX-Evil: true' },
]) {
const f = await bearerFixture();
f.resolveBearer.mockResolvedValueOnce({
state: 'ready',
accessToken: 'resource-only',
expiresAtMs: Date.now() + 60_000,
issuer: f.target.resource.issuer!,
audience: f.target.resource.audience!,
resourceUrl: config.url!,
...change,
});
await expect(f.call()).rejects.toMatchObject({ failure: { reason: 'binding_mismatch' } });
}
});
it('does not deliver a credential after authority is withdrawn during provider resolution', async () => {
const f = await bearerFixture();
f.resolveBearer.mockImplementationOnce(async () => {
await f.revoke();
return {
state: 'ready',
accessToken: 'private',
expiresAtMs: Date.now() + 60_000,
issuer: f.target.resource.issuer!,
audience: f.target.resource.audience!,
resourceUrl: config.url!,
};
});
await expect(f.call()).rejects.toMatchObject({ failure: { reason: 'consent_revoked' } });
});
it('cancels a stalled adapter, does not disclose provider errors, and permits a later deliberate retry', async () => {
const f = await bearerFixture();
const controller = new AbortController();
f.resolveBearer.mockImplementationOnce(() => new Promise(() => {}));
const pending = resolveScheduledMCPBearerConfig({ ...f.input, signal: controller.signal });
await new Promise((resolve) => setTimeout(resolve, 15));
controller.abort();
await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
});
it('withholds provider completion when request cleanup closes the occurrence during minting', async () => {
const f = await bearerFixture();
f.resolveBearer.mockImplementationOnce(async () => {
f.context.cleanupStarted = true;
return {
state: 'ready',
accessToken: 'resource-only',
expiresAtMs: Date.now() + 60_000,
issuer: f.target.resource.issuer!,
audience: f.target.resource.audience!,
resourceUrl: config.url!,
};
});
await expect(f.call()).rejects.toMatchObject({ failure: { reason: 'binding_mismatch' } });
});
it('closes scheduled authority at request cleanup without closing unscheduled calls', async () => {
const unscheduled = createMCPRequestContext();
const scheduled = createMCPRequestContext();
attachScheduledMCPBearer(scheduled, identity);
await cleanupMCPRequestContext(unscheduled);
await cleanupMCPRequestContext(scheduled);
expect(unscheduled.cleanupStarted).toBe(true);
expect(scheduled.cleanupStarted).toBe(true);
// A detached child's interactive call after its parent turn cleaned up keeps the declared config.
await expect(
resolveScheduledMCPBearerConfig({ context: unscheduled, config, user, serverName: 'Files' }),
).resolves.toBe(config);
await expect(
resolveScheduledMCPBearerConfig({ context: scheduled, config, user, serverName: 'Files' }),
).rejects.toMatchObject({
name: 'ScheduledMCPBearerError',
failure: { reason: 'binding_mismatch' },
});
});
it('does not let one cancelled waiter cancel shared minting for a sibling', async () => {
const f = await bearerFixture();
let resolve!: (result: ScheduledMCPBearerResult) => void;
const grant = new Promise<ScheduledMCPBearerResult>((done) => {
resolve = done;
});
f.resolveBearer.mockImplementationOnce(() => grant);
const controller = new AbortController();
const first = resolveScheduledMCPBearerConfig({ ...f.input, signal: controller.signal });
const second = resolveScheduledMCPBearerConfig(f.input);
await new Promise((done) => setTimeout(done, 15));
controller.abort();
await expect(first).rejects.toMatchObject({ name: 'AbortError' });
resolve({
state: 'ready',
accessToken: 'resource-only',
expiresAtMs: Date.now() + 60_000,
issuer: f.target.resource.issuer!,
audience: f.target.resource.audience!,
resourceUrl: config.url!,
});
await expect(second).resolves.toMatchObject({
headers: { Authorization: 'Bearer resource-only' },
});
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
});
it('uses requestHeaders Authorization precedence without losing declared resource binding', async () => {
const definition: ParsedServerConfig = {
...config,
headers: { Authorization: 'Bearer obsolete-static' },
requestHeaders: {
authorization: 'Bearer {{LIBRECHAT_OPENID_ACCESS_TOKEN}}',
'X-Route': 'effective-route',
},
};
const f = await bearerFixture(definition);
const resolved = await f.call();
expect(resolved).toMatchObject({
headers: { authorization: 'Bearer resource-only', 'X-Route': 'effective-route' },
});
expect('headers' in resolved ? resolved.headers?.Authorization : undefined).toBeUndefined();
expect('requestHeaders' in resolved).toBe(false);
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
});
it('maps adapter outages to retryable safe errors without exposing credential/provider details', async () => {
const f = await bearerFixture();
f.resolveBearer.mockRejectedValueOnce(new Error('SECRET provider response'));
const result = await f.call().catch((error: Error) => error);
expect(result).toMatchObject({ retryable: true, failure: { reason: 'dependency_unavailable' } });
expect(String(result)).not.toContain('SECRET');
await f.call();
});
it('preserves static, stored OAuth, and OBO sibling credential ownership', async () => {
const f = await bearerFixture();
for (const sibling of [
{ type: 'streamable-http', url: config.url },
{ ...config, obo: { scopes: 'obo-read' } },
{ ...config, oauth: { client_id: 'direct' } },
]) {
const result = await resolveScheduledMCPBearerConfig({
...f.input,
config: sibling as ParsedServerConfig,
});
expect(result).toBe(sibling);
}
expect(f.resolveBearer).not.toHaveBeenCalled();
await expect(resolveScheduledMCPBearerConfig({ ...f.input, context: undefined })).resolves.toBe(
config,
);
});
it('blocks token placeholders outside Authorization even on an accepted destination', async () => {
const f = await bearerFixture();
const changed = {
...config,
headers: { ...config.headers, 'X-Leak': '{{LIBRECHAT_OPENID_ACCESS_TOKEN}}' },
};
await expect(
resolveScheduledMCPBearerConfig({ ...f.input, config: changed }),
).rejects.toMatchObject({ failure: { reason: 'binding_mismatch' } });
expect(f.resolveBearer).not.toHaveBeenCalled();
});
it('restores the enrolled root after restart, never serializing the resource bearer in job metadata', async () => {
const f = await bearerFixture();
const metadata = {
userId: user.id,
tenantId: user.tenantId,
scheduleId: identity.scheduleId,
agent_id: identity.agentId,
};
const restored = restoreScheduledTokenContext({ user }, metadata)!;
const req = { user, _isScheduledFire: true, body: {} };
const context = createMCPRequestContext();
prepareScheduledMCPBearer({ req, restoredContext: restored, context, host: f.host });
const invocation = bindScheduledMCPBearerInvocation(context, 'child', 'echo')!;
await expect(invocation.resolve({ config, user, serverName: 'Files' })).resolves.toMatchObject({
headers: { Authorization: 'Bearer resource-only' },
});
await f.revoke();
await expect(invocation.resolve({ config, user, serverName: 'Files' })).rejects.toMatchObject({
failure: { reason: 'consent_revoked' },
});
expect(JSON.stringify(metadata)).not.toContain('resource-only');
});
it('ignores forged ordinary scheduling payloads and keeps old incomplete resumes deny-only', async () => {
prepareScheduledMCPBearer({ req: { user, body: { scheduleId: 'forged' } } });
const context = createMCPRequestContext();
prepareScheduledMCPBearer({ req: { user, _isScheduledFire: true, body: {} }, context });
await expect(
resolveScheduledMCPBearerConfig({ context, config, user, serverName: 'Files' }),
).rejects.toMatchObject({ failure: { reason: 'provider_missing' } });
const sibling = { type: 'streamable-http' as const, url: config.url! };
await expect(
resolveScheduledMCPBearerConfig({ context, config: sibling, user, serverName: 'Static' }),
).resolves.toBe(sibling);
});
it.each(['credential_rejected', 'resource_permission_denied'] as const)(
'retires %s for the occurrence without auto-minting or tool replay',
async (reason) => {
const f = await bearerFixture();
await f.call();
rejectScheduledMCPBearer(f.context, 'Files', reason);
await expect(f.call()).rejects.toMatchObject({
failure: { reason, automaticReplay: false },
});
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
},
);
it('uses the host adapter at scheduled preflight and preserves missing-adapter diagnosis', async () => {
const f = await bearerFixture();
const deps: Parameters<typeof createScheduleMCPPreflight>[0] = {
scheduledBearerHost: f.host,
getUser: async () => user,
getRoleByName: async () =>
({ permissions: { [PermissionTypes.MCP_SERVERS]: { [Permissions.USE]: true } } }) as IRole,
resolveAgentGraphAccess: async () => ({}) as never,
getAgentGraphNodes: async (ids) =>
ids.map((id) => ({ id, provider: 'test', model: 'test', tools: ['echo_mcp_Files'] })),
getModelsConfig: async () => ({ test: ['test'] }),
getAppConfig: async () =>
({ endpoints: { agents: { capabilities: [AgentCapabilities.tools] } } }) as AppConfig,
ensureConfigServers: async () => ({}),
getServerConfigs: async () => ({ Files: config }),
findPluginAuthsByKeys: async () => [],
connect: async (options) => {
await resolveScheduledMCPBearerConfig({
user,
serverName: options.serverName,
config,
context: options.requestScopedConnections,
});
return {
fetchToolsSnapshot: async () => ({
tools: [{ name: 'echo', inputSchema: { type: 'object' as const } }],
complete: true,
}),
};
},
};
await expect(
createScheduleMCPPreflight(deps)('root', user, { scheduleId: 'schedule', concurrency: 2 }),
).resolves.toEqual([{ server: 'Files', status: 'ready' }]);
await expect(
createScheduleMCPPreflight({ ...deps, scheduledBearerHost: undefined })('root', user, {
scheduleId: 'schedule',
concurrency: 2,
}),
).rejects.toMatchObject({ outcomes: [expect.objectContaining({ reason: 'provider_missing' })] });
});
describe('scheduled resource bearer with real MCP SDK and HTTP', () => {
it.each(['consent_revoked', 'rbac_denied'] as const)(
'preserves the original %s after real session setup and before required catalog reads',
async (reason) => {
let requests = 0;
const server = await createOAuthMCPServer({
onResourceRequest: (req) => {
if (req.method !== 'DELETE') requests++;
},
});
const definition: ParsedServerConfig = { ...config, url: server.url, requiresOAuth: false };
const f = await bearerFixture(definition);
server.issuedTokens.add('resource-only');
server.tokenIssueTimes.set('resource-only', Date.now());
const connection = await MCPConnectionFactory.create(
{
serverName: 'Files',
serverConfig: definition,
ephemeralConnection: true,
useSSRFProtection: false,
},
{ user, requestScopedConnections: f.context },
);
try {
await connection.fetchToolsSnapshot();
if (reason === 'consent_revoked') await f.revoke();
else f.deny();
const before = requests;
const read = connection.fetchOrderedToolsSnapshot();
await expect(read).rejects.toMatchObject({
failure: { reason },
outcomes: [expect.objectContaining({ server: 'Files', reason, automaticReplay: false })],
});
await expect(connection.fetchTools()).rejects.toMatchObject({ failure: { reason } });
await expect(connection.refreshToolList()).rejects.toMatchObject({ failure: { reason } });
expect(requests).toBe(before);
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
} finally {
await connection.dispose();
await cleanupMCPRequestContext(f.context);
MCPConnection.clearCooldown('Files');
await server.close();
}
},
);
it.each(['revoke', 'expiry', 'automatic'] as const)(
'withholds automatic session reopening after %s without replay',
async (change) => {
let requests = 0;
const server = await createOAuthMCPServer({
onResourceRequest: (req) => {
if (req.method !== 'DELETE') requests++;
},
});
const definition: ParsedServerConfig = { ...config, url: server.url, requiresOAuth: false };
const f = await bearerFixture(definition);
server.issuedTokens.add('resource-only');
server.tokenIssueTimes.set('resource-only', Date.now());
const connection = await MCPConnectionFactory.create(
{
serverName: 'Files',
serverConfig: definition,
ephemeralConnection: true,
useSSRFProtection: false,
},
{ user, requestScopedConnections: f.context },
);
try {
await connection.fetchToolsSnapshot();
if (change !== 'expiry') await f.revoke();
else f.advance(60 * 60_000 + 1);
const before = requests;
if (change === 'automatic') {
const connect = jest.spyOn(connection, 'connect');
await connection['handleReconnection']();
expect(connect).toHaveBeenCalledTimes(1);
await expect(connect.mock.results[0].value).rejects.toMatchObject({
failure: { reason: 'consent_revoked' },
});
connect.mockRestore();
} else
await expect(connection.connect()).rejects.toMatchObject({
failure: { reason: change === 'revoke' ? 'consent_revoked' : 'consent_expired' },
});
// Teardown DELETE is permitted; initialize and catalog requests are withheld.
expect(requests).toBe(before);
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
} finally {
await connection.dispose();
await cleanupMCPRequestContext(f.context);
MCPConnection.clearCooldown('Files');
await server.close();
}
},
);
it('runs headlessly across expiry, reconnect and restart without replaying rejected calls', async () => {
const seen: string[] = [];
let calls = 0;
const server = await createOAuthMCPServer({
onResourceRequest: (req) => {
if (req.headers.authorization) seen.push(req.headers.authorization);
},
echoHandler: (message) => {
calls++;
return message;
},
});
const definition: ParsedServerConfig = {
...config,
url: server.url,
requiresOAuth: false,
initTimeout: 1000,
};
const f = await bearerFixture(definition);
let counter = 0;
f.resolveBearer.mockImplementation(async () => {
const token = `resource-${++counter}`;
server.issuedTokens.add(token);
server.tokenIssueTimes.set(token, Date.now());
return {
state: 'ready',
accessToken: token,
expiresAtMs: Date.now() + 60_000,
issuer: f.target.resource.issuer!,
audience: f.target.resource.audience!,
resourceUrl: server.url,
};
});
const flowManager = new FlowStateManager<MCPOAuthTokens | null>(
new MockKeyv() as unknown as Keyv,
{ ci: true, ttl: 30000 },
);
const manager = new MCPManager();
const registry = jest.spyOn(MCPServersRegistry, 'getInstance').mockReturnValue({
isAppServerConfig: async () => false,
isHiddenFromPrincipal: async () => false,
resolveAllowlists: async () => ({
allowedDomains: ['127.0.0.1'],
allowedAddresses: [`127.0.0.1:${server.port}`],
useSSRFProtection: false,
}),
} as unknown as MCPServersRegistry);
const contexts = [f.context];
const input = {
user,
serverName: 'Files',
serverConfig: definition,
requestScopedConnections: f.context,
flowManager,
};
const call = (toolName = 'echo', agent = 'root') =>
manager.callTool({
...input,
provider: 'openai',
toolName,
toolArguments: { message: 'headless' },
scheduledBearerInvocation: bindScheduledMCPBearerInvocation(
input.requestScopedConnections,
agent,
toolName,
),
});
try {
const connected = await manager.getConnection(input);
expect(input.requestScopedConnections.connections.size).toBe(1);
expect(manager.getUserConnections(user.id)).toBeUndefined();
expect((await connected.fetchToolsSnapshot()).tools.map((tool) => tool.name)).toContain(
'echo',
);
await call();
await call('echo', 'child');
expect(calls).toBe(2);
expect(counter).toBe(1);
f.advance(120_001);
f.resolveBearer.mockImplementation(async () => {
const token = `resource-${++counter}`;
server.issuedTokens.add(token);
server.tokenIssueTimes.set(token, Date.now());
return {
state: 'ready',
accessToken: token,
expiresAtMs: Date.now() + 180_000,
issuer: f.target.resource.issuer!,
audience: f.target.resource.audience!,
resourceUrl: server.url,
};
});
await call();
expect(counter).toBe(2);
expect(calls).toBe(3);
await connected.disconnect();
await call();
expect(counter).toBe(2);
expect(calls).toBe(4);
await expect(call('write')).rejects.toMatchObject({
failure: { reason: 'tool_policy_denied' },
});
expect(calls).toBe(4);
server.issuedTokens.clear();
await expect(call()).rejects.toMatchObject({
failure: { reason: 'credential_rejected', automaticReplay: false },
});
expect(counter).toBe(2);
expect(calls).toBe(4);
await expect(call()).rejects.toMatchObject({ failure: { reason: 'credential_rejected' } });
expect(counter).toBe(2);
const resumed = createMCPRequestContext();
contexts.push(resumed);
prepareScheduledMCPBearer({
req: { user, _isScheduledFire: true, body: {} },
context: resumed,
host: f.host,
restoredContext: restoreScheduledTokenContext(
{ user },
{
userId: user.id,
tenantId: user.tenantId,
scheduleId: identity.scheduleId,
agent_id: 'root',
},
),
});
input.requestScopedConnections = resumed;
await call('echo', 'child');
expect(counter).toBe(3);
expect(calls).toBe(5);
await f.revoke();
await expect(call()).rejects.toMatchObject({ failure: { reason: 'consent_revoked' } });
expect(calls).toBe(5);
expect(server.tokenRequests).toEqual([]);
expect(seen.some((header) => header.includes('resource-'))).toBe(true);
} finally {
await Promise.all(contexts.map((context) => cleanupMCPRequestContext(context)));
registry.mockRestore();
MCPConnection.clearCooldown('Files');
await server.close();
}
});
it.each([false, true])(
'isolates cold and restored scheduled checkout from a warm browser pool, requestHeaders=%s',
async (requestHeaders) => {
const observed: string[] = [];
const server = await createOAuthMCPServer({
onResourceRequest: (req) => {
if (req.headers.authorization) observed.push(req.headers.authorization);
},
});
const definition: ParsedServerConfig = {
...config,
url: server.url,
requiresOAuth: false,
...(requestHeaders ? { headers: {}, requestHeaders: config.headers } : {}),
};
const f = await bearerFixture(definition);
for (const token of ['browser-only', 'resource-only']) {
server.issuedTokens.add(token);
server.tokenIssueTimes.set(token, Date.now());
}
const manager = new MCPManager();
const upstreamTokenProvider = jest.fn(async () => ({ access_token: 'browser-only' }));
const registry = jest.spyOn(MCPServersRegistry, 'getInstance').mockReturnValue({
isAppServerConfig: async () => false,
isHiddenFromPrincipal: async () => false,
resolveAllowlists: async () => ({
allowedDomains: ['127.0.0.1'],
allowedAddresses: [`127.0.0.1:${server.port}`],
useSSRFProtection: false,
}),
} as unknown as MCPServersRegistry);
const restored = createMCPRequestContext();
const flowManager = new FlowStateManager<MCPOAuthTokens | null>(
new MockKeyv() as unknown as Keyv,
{ ci: true, ttl: 30000 },
);
try {
const browser = await manager.getConnection({
user,
serverName: 'Files',
serverConfig: definition,
upstreamTokenProvider,
});
expect(manager.getUserConnections(user.id)?.get('Files')).toBe(browser);
upstreamTokenProvider.mockClear();
prepareScheduledMCPBearer({
req: { user, _isScheduledFire: true, body: {} },
context: restored,
host: f.host,
restoredContext: restoreScheduledTokenContext(
{ user },
{
userId: user.id,
tenantId: user.tenantId,
scheduleId: identity.scheduleId,
agent_id: 'root',
},
),
});
observed.length = 0;
const connections: MCPConnection[] = [];
for (const context of [f.context, restored]) {
await manager.callTool({
user,
serverName: 'Files',
serverConfig: definition,
provider: 'openai',
toolName: 'echo',
toolArguments: { message: 'scoped' },
flowManager,
requestScopedConnections: context,
upstreamTokenProvider,
scheduledBearerInvocation: bindScheduledMCPBearerInvocation(context, 'child', 'echo'),
});
expect(context.connections.size).toBe(1);
const connection = [...context.connections.values()][0] as MCPConnection;
expect(connection).not.toBe(browser);
connections.push(connection);
}
expect(connections[0]).not.toBe(connections[1]);
expect(upstreamTokenProvider).not.toHaveBeenCalled();
expect(f.resolveBearer).toHaveBeenCalledTimes(2);
expect(observed.length).toBeGreaterThan(0);
expect(observed.every((header) => header === 'Bearer resource-only')).toBe(true);
expect(manager.getUserConnections(user.id)?.get('Files')).toBe(browser);
await cleanupMCPRequestContext(f.context);
expect(restored.connections.size).toBe(1);
expect(await browser.isConnected()).toBe(true);
} finally {
await cleanupMCPRequestContext(f.context);
await cleanupMCPRequestContext(restored);
await manager.disconnectUserConnections(user.id);
registry.mockRestore();
MCPConnection.clearCooldown('Files');
await server.close();
}
},
);
it.each(['invoke', 'resume'] as const)(
'enforces the merged A3 ceiling with a B2 bearer at %s',
async (stage) => {
let calls = 0;
const server = await createOAuthMCPServer({
echoHandler: (message) => {
calls++;
return message;
},
});
const definition: ParsedServerConfig = { ...config, url: server.url, requiresOAuth: false };
const f = await bearerFixture(definition);
server.issuedTokens.add('resource-only');
server.tokenIssueTimes.set('resource-only', Date.now());
const manager = new MCPManager();
const registry = jest.spyOn(MCPServersRegistry, 'getInstance').mockReturnValue({
isAppServerConfig: async () => false,
isHiddenFromPrincipal: async () => false,
resolveAllowlists: async () => ({
allowedDomains: ['127.0.0.1'],
allowedAddresses: [`127.0.0.1:${server.port}`],
useSSRFProtection: false,
}),
} as unknown as MCPServersRegistry);
const flowManager = new FlowStateManager<MCPOAuthTokens | null>(
new MockKeyv() as unknown as Keyv,
{ ci: true, ttl: 30000 },
);
try {
const input = {
user,
serverName: 'Files',
serverConfig: definition,
requestScopedConnections: f.context,
flowManager,
};
const connected = await manager.getConnection(input);
const catalog = await connected.fetchToolsSnapshot();
const echo = catalog.tools.find((tool) => tool.name === 'echo')!;
let digest = getScheduledMCPToolDefinitionDigest(echo);
const execution = createScheduleMCPExecution({
storage: f.storage,
loadAuthorization: async () => ({
authority: f.consent.authority,
policy: {
Files: { tools: { echo: { effect: 'read_only', definitionSha256: digest } } },
},
}),
});
await execution.attach(f.context, identity, stage, true);
const call = () =>
manager.callTool({
...input,
provider: 'openai',
toolName: 'echo',
toolArguments: { message: 'guarded' },
scheduledBearerInvocation: bindScheduledMCPBearerInvocation(f.context, 'child', 'echo'),
scheduledMCPInvocation: bindScheduledMCPInvocation(f.context, 'child', 'echo'),
});
await call();
expect(calls).toBe(1);
digest = '0'.repeat(64);
await expect(call()).rejects.toMatchObject({ failure: { reason: 'tool_policy_denied' } });
expect(calls).toBe(1);
expect(server.tokenRequests).toEqual([]);
expect(manager.getUserConnections(user.id)).toBeUndefined();
} finally {
registry.mockRestore();
await cleanupMCPRequestContext(f.context);
MCPConnection.clearCooldown('Files');
await server.close();
}
},
);
it('retains effective request headers on an unrelated scheduled static sibling', async () => {
const observed: Array<string | undefined> = [];
const server = await createOAuthMCPServer({
onResourceRequest: (req) => observed.push(req.headers['x-route'] as string | undefined),
});
server.issuedTokens.add('static-key');
server.tokenIssueTimes.set('static-key', Date.now());
const context = createMCPRequestContext();
attachScheduledMCPBearer(context, identity);
let connection: MCPConnection | undefined;
try {
connection = await MCPConnectionFactory.create(
{
serverName: 'Static',
useSSRFProtection: false,
serverConfig: {
type: 'streamable-http',
url: server.url,
headers: { Authorization: 'Bearer static-key' },
requestHeaders: { 'X-Route': 'sibling-route' },
requiresOAuth: false,
},
},
{ user, requestScopedConnections: context },
);
await connection.fetchToolsSnapshot();
expect(observed.filter(Boolean)).toEqual(expect.arrayContaining(['sibling-route']));
expect(observed.every((value) => value === 'sibling-route')).toBe(true);
} finally {
await connection?.dispose();
await cleanupMCPRequestContext(context);
await server.close();
}
});
it('changes only Authorization at invocation, preserving expanded routing headers', async () => {
process.env.B2_ROUTE = 'resolved-route';
const observed: Array<string | undefined> = [];
const server = await createOAuthMCPServer({
onResourceRequest: (req) => observed.push(req.headers['x-route'] as string | undefined),
});
const definition: ParsedServerConfig = {
...config,
url: server.url,
requiresOAuth: false,
headers: { ...config.headers, 'X-Route': '${B2_ROUTE}' },
};
const f = await bearerFixture(definition);
server.issuedTokens.add('resource-only');
server.tokenIssueTimes.set('resource-only', Date.now());
const manager = new MCPManager();
const registry = jest.spyOn(MCPServersRegistry, 'getInstance').mockReturnValue({
isAppServerConfig: async () => false,
isHiddenFromPrincipal: async () => false,
resolveAllowlists: async () => ({
allowedDomains: ['127.0.0.1'],
allowedAddresses: [`127.0.0.1:${server.port}`],
useSSRFProtection: false,
}),
} as unknown as MCPServersRegistry);
try {
await manager.callTool({
user,
serverName: 'Files',
serverConfig: definition,
provider: 'openai',
toolName: 'echo',
toolArguments: { message: 'routing' },
requestScopedConnections: f.context,
scheduledBearerInvocation: bindScheduledMCPBearerInvocation(f.context, 'root', 'echo'),
flowManager: new FlowStateManager<MCPOAuthTokens | null>(
new MockKeyv() as unknown as Keyv,
{ ttl: 30000, ci: true },
),
});
expect(observed.length).toBeGreaterThan(0);
expect(observed.every((route) => route === 'resolved-route')).toBe(true);
} finally {
registry.mockRestore();
await cleanupMCPRequestContext(f.context);
MCPConnection.clearCooldown('Files');
await server.close();
delete process.env.B2_ROUTE;
}
});
it('preflights a real protected resource without browser auth and preserves bearer rejection', async () => {
const server = await createOAuthMCPServer();
const definition: ParsedServerConfig = {
...config,
url: server.url,
requiresOAuth: false,
initTimeout: 1000,
};
const f = await bearerFixture(definition);
server.issuedTokens.add('resource-only');
server.tokenIssueTimes.set('resource-only', Date.now());
const manager = new MCPManager();
const registry = jest.spyOn(MCPServersRegistry, 'getInstance').mockReturnValue({
isAppServerConfig: async () => false,
isHiddenFromPrincipal: async () => false,
resolveAllowlists: async () => ({
allowedDomains: ['127.0.0.1'],
allowedAddresses: [`127.0.0.1:${server.port}`],
useSSRFProtection: false,
}),
} as unknown as MCPServersRegistry);
const flowManager = new FlowStateManager<MCPOAuthTokens | null>(
new MockKeyv() as unknown as Keyv,
{ ttl: 30000, ci: true },
);
const deps: Parameters<typeof createScheduleMCPPreflight>[0] = {
scheduledBearerHost: f.host,
getUser: async () => user,
getRoleByName: async () =>
({ permissions: { [PermissionTypes.MCP_SERVERS]: { [Permissions.USE]: true } } }) as IRole,
resolveAgentGraphAccess: async () => ({}) as never,
getAgentGraphNodes: async (ids) =>
ids.map((id) => ({ id, provider: 'test', model: 'test', tools: ['echo_mcp_Files'] })),
getModelsConfig: async () => ({ test: ['test'] }),
getAppConfig: async () =>
({ endpoints: { agents: { capabilities: [AgentCapabilities.tools] } } }) as AppConfig,
ensureConfigServers: async () => ({}),
getServerConfigs: async () => ({ Files: definition }),
findPluginAuthsByKeys: async () => [],
connect: (options) => manager.getConnection({ ...options, flowManager }),
};
try {
const preflight = createScheduleMCPPreflight(deps);
await expect(
preflight('root', user, { scheduleId: 'schedule', concurrency: 2 }),
).resolves.toEqual([{ server: 'Files', status: 'ready' }]);
f.snapshot.enabled = false;
for (const admission of [{ stage: 'activation' as const }, { manual: true }]) {
await expect(
preflight('root', user, { scheduleId: 'schedule', concurrency: 2, ...admission }),
).resolves.toEqual([{ server: 'Files', status: 'ready' }]);
}
await expect(
preflight('root', user, { scheduleId: 'schedule', concurrency: 2 }),
).rejects.toMatchObject({
outcomes: [expect.objectContaining({ reason: 'binding_mismatch' })],
});
f.snapshot.enabled = true;
server.issuedTokens.clear();
await expect(
preflight('root', user, { scheduleId: 'schedule', concurrency: 2 }),
).rejects.toMatchObject({
outcomes: [expect.objectContaining({ reason: 'credential_rejected' })],
});
expect(server.tokenRequests).toEqual([]);
} finally {
registry.mockRestore();
MCPConnection.clearCooldown('Files');
await server.close();
}
});
it('denies the absent host before SDK setup can reuse browser credentials', async () => {
let observed = 0;
const server = await createOAuthMCPServer({
onResourceRequest: () => {
observed++;
},
});
const context = createMCPRequestContext();
attachScheduledMCPBearer(context, identity);
const session = jest.fn(async () => ({ access_token: 'browser-login' }));
try {
await expect(
MCPConnectionFactory.create(
{
serverName: 'Files',
serverConfig: { ...config, url: server.url },
useSSRFProtection: false,
},
{ user, requestScopedConnections: context, upstreamTokenProvider: session },
),
).rejects.toMatchObject({ failure: { reason: 'provider_missing' } });
expect(session).not.toHaveBeenCalled();
expect(observed).toBe(0);
} finally {
await cleanupMCPRequestContext(context);
await server.close();
}
});
});
it('classifies a pre-transport RBAC denial without altering ordinary permission errors', async () => {
const f = await bearerFixture();
const invocation = bindScheduledMCPBearerInvocation(f.context, 'child', 'echo');
expect(createMCPPermissionDeniedError(invocation, 'Files', config)).toMatchObject({
failure: { reason: 'rbac_denied' },
});
expect(createMCPPermissionDeniedError(undefined, 'Files', config).message).toBe(
'Forbidden: Insufficient MCP server permissions',
);
});
it('cancels the occurrence-owned mint without aborting another occurrence or accepting late credentials', async () => {
const f = await bearerFixture();
const other = await bearerFixture();
let deliver!: (value: ScheduledMCPBearerResult) => void;
let entered!: () => void;
const started = new Promise<void>((resolve) => {
entered = resolve;
});
const provider = new Promise<ScheduledMCPBearerResult>((resolve) => {
deliver = resolve;
});
let mintSignal: AbortSignal | undefined;
const token: ScheduledMCPBearerResult = {
state: 'ready',
accessToken: 'late-only',
expiresAtMs: Date.now() + 60_000,
issuer: f.target.resource.issuer!,
audience: f.target.resource.audience!,
resourceUrl: f.target.resource.url,
};
f.resolveBearer.mockImplementationOnce(async (_request, options) => {
mintSignal = options.signal;
entered();
return provider;
});
const first = f.call().catch((error) => error);
const sibling = f.call('child').catch((error) => error);
try {
await started;
await quiesceMCPRequestContext(f.context);
const abortedBeforeRelease = mintSignal?.aborted;
const early = await Promise.race([
Promise.all([first, sibling]),
new Promise<string>((resolve) => setTimeout(() => resolve('still waiting'), 100)),
]);
deliver(token);
const outcomes = await Promise.all([first, sibling]);
expect(abortedBeforeRelease).toBe(true);
expect(early).not.toBe('still waiting');
for (const error of outcomes) expect(error).toMatchObject({ name: 'AbortError' });
await expect(other.call()).resolves.toMatchObject({
headers: expect.objectContaining({ Authorization: 'Bearer resource-only' }),
});
await expect(f.call()).rejects.toMatchObject({ name: 'AbortError' });
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
} finally {
deliver(token);
await Promise.all([first, sibling]);
await cleanupMCPRequestContext(f.context);
await cleanupMCPRequestContext(other.context);
}
});
it('detaches stalled enrollment at the occurrence cutoff and withholds its late result', async () => {
const f = await bearerFixture();
let entered!: () => void, release!: (value: ScheduledMCPTarget[]) => void;
const started = new Promise<void>((resolve) => {
entered = resolve;
});
const enrollment = new Promise<ScheduledMCPTarget[]>((resolve) => {
release = resolve;
});
f.resolveEnrollment.mockImplementationOnce(async () => {
entered();
return enrollment;
});
const result = f.call().catch((error) => error);
try {
await started;
await quiesceMCPRequestContext(f.context);
await expect(result).resolves.toMatchObject({ name: 'AbortError' });
release([f.target]);
expect(f.resolveBearer).not.toHaveBeenCalled();
} finally {
release([f.target]);
await result;
await cleanupMCPRequestContext(f.context);
}
});
it('disposes a connection credential waiter without cancelling its sibling shared mint', async () => {
const server = await createOAuthMCPServer();
const definition: ParsedServerConfig = { ...config, url: server.url, requiresOAuth: false };
const f = await bearerFixture(definition);
let release!: (token: ScheduledMCPBearerResult) => void, entered!: () => void;
const started = new Promise<void>((resolve) => {
entered = resolve;
});
const mint = new Promise<ScheduledMCPBearerResult>((resolve) => {
release = resolve;
});
let mintSignal: AbortSignal | undefined;
f.resolveBearer.mockImplementationOnce(async (_input, options) => {
mintSignal = options.signal;
entered();
return mint;
});
const headers = createScheduledMCPBearerHeaderResolver({ ...f.input, config: definition });
const first = new MCPConnection({
serverName: 'Files',
serverConfig: { ...definition, initTimeout: 30 },
resolveRequestHeaders: headers,
});
const second = new MCPConnection({
serverName: 'Files',
serverConfig: { ...definition, initTimeout: 2000 },
resolveRequestHeaders: headers,
});
const close = jest.spyOn(first.client, 'close');
server.issuedTokens.add('resource-only');
server.tokenIssueTimes.set('resource-only', Date.now());
const token: ScheduledMCPBearerResult = {
state: 'ready',
accessToken: 'resource-only',
expiresAtMs: Date.now() + 60_000,
issuer: f.target.resource.issuer!,
audience: f.target.resource.audience!,
resourceUrl: server.url,
};
const failed = first.connectClient().catch(async (error) => {
await first.dispose();
return error;
});
let sibling: Promise<void> | undefined;
try {
await started;
sibling = second.connectClient();
await expect(failed).resolves.toMatchObject({ message: expect.stringContaining('timeout') });
expect(close).toHaveBeenCalled();
expect(mintSignal?.aborted).toBe(false);
expect(f.context.cleanupStarted).toBe(false);
release(token);
await sibling;
await expect(second.fetchToolsSnapshot()).resolves.toMatchObject({ complete: true });
expect(f.resolveBearer).toHaveBeenCalledTimes(1);
await expect(first.client.listTools()).rejects.toThrow();
} finally {
release(token);
await failed;
await sibling?.catch(() => undefined);
await first.dispose();
await second.dispose();
await cleanupMCPRequestContext(f.context);
MCPConnection.clearCooldown('Files');
await server.close();
}
}, 10_000);