Skip to content

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

🪪 feat: Pass Schedule Identity to MCP Token Providers (#15962)

Danny Avila21a9edbe7481
diff --git a/api/server/controllers/agents/__tests__/resume.spec.js b/api/server/controllers/agents/__tests__/resume.spec.js
index 866d09024d..33ff36bc5d 100644
--- a/api/server/controllers/agents/__tests__/resume.spec.js
+++ b/api/server/controllers/agents/__tests__/resume.spec.js
@@ -1275,6 +1275,13 @@ describe('ResumeAgentController (POST /agents/chat/resume)', () => {
await settled;
expect(capturedInit.isScheduledFire).toBe(true);
+ expect(mockInitializeClient.mock.calls[0][0].scheduledTokenContext).toEqual({
+ scheduleId: 'schedule-1',
+ ownerId: USER_ID,
+ tenantId: TENANT_ID,
+ agentId: AGENT_ID,
+ invocationMode: 'delegated',
+ });
expect(mockClaimScheduleResume).toHaveBeenCalledWith('schedule-1', scheduledFor, {
expectedConfigRevision: 4,
diff --git a/api/server/controllers/agents/resume.js b/api/server/controllers/agents/resume.js
index 96e481c7f4..2cc9a112d7 100644
--- a/api/server/controllers/agents/resume.js
+++ b/api/server/controllers/agents/resume.js
@@ -47,6 +47,7 @@ const {
findAgentEventAppliedAction,
assertCodeExecutionApprovalBinding,
collectReachableAgents,
+ restoreScheduledTokenContext,
} = require('@librechat/api');
const { disposeClient } = require('~/server/cleanup');
const { decryptMetadata } = require('~/server/services/ActionService');
@@ -1812,6 +1813,7 @@ const ResumeAgentController = async (req, res, next, initializeClient, addTitle)
parentMessageId: job.metadata.userMessage?.messageId ?? Constants.NO_PARENT,
});
const result = await initializeClient({
+ scheduledTokenContext: restoreScheduledTokenContext(req, job.metadata),
req,
res,
endpointOption: req.body.endpointOption,
diff --git a/api/server/services/Endpoints/agents/initialize.js b/api/server/services/Endpoints/agents/initialize.js
index 6c826220c5..ee8ebb207d 100644
--- a/api/server/services/Endpoints/agents/initialize.js
+++ b/api/server/services/Endpoints/agents/initialize.js
@@ -1873,7 +1873,7 @@ const initializeClientWithProvider = async ({
* token material so refresh remains owned by the host integration.
*
* @param {object} [dependencies]
- * @param {(user: import('@librechat/data-schemas').IUser, options: { signal?: AbortSignal }) => import('@librechat/api').UpstreamTokenProvider | undefined | Promise<import('@librechat/api').UpstreamTokenProvider | undefined>} [dependencies.resolveUpstreamTokenProvider]
+ * @param {import('@librechat/api').HostUpstreamTokenProviderResolver} [dependencies.resolveUpstreamTokenProvider]
*/
function createInitializeClient(dependencies = {}) {
return async (params) => {
@@ -1881,6 +1881,7 @@ function createInitializeClient(dependencies = {}) {
params.req,
dependencies.resolveUpstreamTokenProvider,
params.signal,
+ params.scheduledTokenContext,
);
return initializeClientWithProvider({ ...params, upstreamTokenProviderResolver });
};
diff --git a/api/server/services/Endpoints/agents/initialize.spec.js b/api/server/services/Endpoints/agents/initialize.spec.js
index e76bdbb8c1..b01af98760 100644
--- a/api/server/services/Endpoints/agents/initialize.spec.js
+++ b/api/server/services/Endpoints/agents/initialize.spec.js
@@ -182,12 +182,22 @@ describe('initializeClient — processAgent ACL gate', () => {
},
});
- it('defers host credential resolution during scheduled agent initialization', async () => {
+ it.each([false, true])('defers host credential resolution with restored=%s', async (restored) => {
const upstreamTokenProvider = jest.fn();
const resolveUpstreamTokenProvider = jest.fn().mockResolvedValue(upstreamTokenProvider);
const hostInitializeClient = createInitializeClient({ resolveUpstreamTokenProvider });
const req = makeReq();
req._isScheduledFire = true;
+ req._isAgentTrigger = !restored;
+ req.body.agent_id = PRIMARY_ID;
+ req.body.agentTrigger = {
+ version: 1,
+ event: {
+ type: 'schedule.occurrence',
+ occurredAt: 0,
+ source: { type: 'schedule', id: 'sched-1' },
+ },
+ };
const signal = new AbortController().signal;
mockInitializeAgent.mockImplementationOnce(async ({ loadTools, agent }) => {
await loadTools({
@@ -203,6 +213,14 @@ describe('initializeClient — processAgent ACL gate', () => {
req,
res: {},
signal,
+ scheduledTokenContext: restored
+ ? {
+ scheduleId: 'sched-1',
+ ownerId: req.user.id,
+ agentId: PRIMARY_ID,
+ invocationMode: 'delegated',
+ }
+ : undefined,
endpointOption: makeEndpointOption(),
});
@@ -211,7 +229,15 @@ describe('initializeClient — processAgent ACL gate', () => {
expect(toolLoadParams.upstreamTokenProvider).toBeUndefined();
const resolver = toolLoadParams.upstreamTokenProviderResolver;
await expect(resolver({ signal })).resolves.toBe(upstreamTokenProvider);
- expect(resolveUpstreamTokenProvider).toHaveBeenCalledWith(req.user, { signal });
+ expect(resolveUpstreamTokenProvider).toHaveBeenCalledWith(req.user, {
+ signal,
+ context: {
+ scheduleId: 'sched-1',
+ ownerId: req.user.id,
+ agentId: PRIMARY_ID,
+ invocationMode: 'delegated',
+ },
+ });
});
it('keeps interactive agent initialization independent of the host resolver', async () => {
diff --git a/api/server/services/Schedules/mcp.js b/api/server/services/Schedules/mcp.js
index e87a8909f9..ae358c08f3 100644
--- a/api/server/services/Schedules/mcp.js
+++ b/api/server/services/Schedules/mcp.js
@@ -15,7 +15,7 @@ const methods = require('~/models');
* credential source and therefore remains fail-closed for unattended OBO.
*
* @param {object} [options]
- * @param {(user: import('@librechat/data-schemas').IUser, options: { signal?: AbortSignal }) => import('@librechat/api').UpstreamTokenProvider | undefined | Promise<import('@librechat/api').UpstreamTokenProvider | undefined>} [options.resolveUpstreamTokenProvider]
+ * @param {import('@librechat/api').HostUpstreamTokenProviderResolver} [options.resolveUpstreamTokenProvider]
*/
function createMCPPreflight(options = {}) {
return createScheduleMCPPreflight({
diff --git a/packages/api/src/agents/subagentThreads.spec.ts b/packages/api/src/agents/subagentThreads.spec.ts
index 1d44c2f3cf..32daa78c44 100644
--- a/packages/api/src/agents/subagentThreads.spec.ts
+++ b/packages/api/src/agents/subagentThreads.spec.ts
@@ -1413,9 +1413,12 @@ describe('SubagentThreadTaskStore', () => {
let ownerActive = true;
const options = {
isOwnerActive: async () => ownerActive,
- leaseTtlMs: 60,
+ // Exercise owner cancellation, not lease expiry. Keep the lease beyond the
+ // drain deadline so slow CI database operations cannot bypass child startup
+ // or make the drain succeed without the worker releasing its lease.
+ leaseTtlMs: 30_000,
leaseHeartbeatMs: 10,
- ownerDrainTimeoutMs: 1_000,
+ ownerDrainTimeoutMs: 5_000,
ownerDrainPollMs: 5,
};
const workerStore = new SubagentThreadTaskStore(methods, options);
diff --git a/packages/api/src/mcp/MCPConnectionFactory.ts b/packages/api/src/mcp/MCPConnectionFactory.ts
index 66b3368ea1..6c416ae65a 100644
--- a/packages/api/src/mcp/MCPConnectionFactory.ts
+++ b/packages/api/src/mcp/MCPConnectionFactory.ts
@@ -654,6 +654,7 @@ export class MCPConnectionFactory {
this.upstreamTokenProvider = createLazyOboUpstreamTokenProvider(
this.upstreamTokenProviderResolver,
this.signal,
+ { mcpServer: this.serverName, scopes: oboConfig.scopes },
);
}
if (!this.upstreamTokenProvider) {
diff --git a/packages/api/src/mcp/MCPManager.ts b/packages/api/src/mcp/MCPManager.ts
index 5e9a7825cf..bf5196c382 100644
--- a/packages/api/src/mcp/MCPManager.ts
+++ b/packages/api/src/mcp/MCPManager.ts
@@ -1302,6 +1302,7 @@ Please follow these instructions when using tools from the respective MCP server
oboUpstreamTokenProvider = createLazyOboUpstreamTokenProvider(
upstreamTokenProviderResolver,
options?.signal,
+ { mcpServer: serverName, scopes: oboConfig.scopes },
);
}
if (!oboUpstreamTokenProvider) {
diff --git a/packages/api/src/mcp/__tests__/MCPConnectionFactory.test.ts b/packages/api/src/mcp/__tests__/MCPConnectionFactory.test.ts
index f370a8d12a..ffe06f2773 100644
--- a/packages/api/src/mcp/__tests__/MCPConnectionFactory.test.ts
+++ b/packages/api/src/mcp/__tests__/MCPConnectionFactory.test.ts
@@ -5586,6 +5586,11 @@ describe('MCPConnectionFactory', () => {
);
expect(upstreamTokenProviderResolver).toHaveBeenCalledTimes(1);
+ expect(upstreamTokenProviderResolver).toHaveBeenCalledWith(
+ expect.objectContaining({
+ target: { mcpServer: 'obo-srv', scopes: oboServerConfig.obo?.scopes },
+ }),
+ );
expect(resolveOboToken).toHaveBeenCalledWith(
mockUser,
oboServerConfig.obo,
diff --git a/packages/api/src/mcp/__tests__/MCPManager.test.ts b/packages/api/src/mcp/__tests__/MCPManager.test.ts
index ac8c638cd1..32b75090e3 100644
--- a/packages/api/src/mcp/__tests__/MCPManager.test.ts
+++ b/packages/api/src/mcp/__tests__/MCPManager.test.ts
@@ -2914,6 +2914,11 @@ describe('MCPManager', () => {
});
expect(upstreamTokenProviderResolver).toHaveBeenCalledTimes(1);
+ expect(upstreamTokenProviderResolver).toHaveBeenCalledWith(
+ expect.objectContaining({
+ target: { mcpServer: serverName, scopes: serverConfig.obo?.scopes },
+ }),
+ );
expect(mockResolveOboToken).toHaveBeenCalledWith(
mockUser,
serverConfig.obo,
diff --git a/packages/api/src/mcp/oauth/obo.ts b/packages/api/src/mcp/oauth/obo.ts
index 878dfee4ac..32fca35f2e 100644
--- a/packages/api/src/mcp/oauth/obo.ts
+++ b/packages/api/src/mcp/oauth/obo.ts
@@ -45,9 +45,16 @@ export type UpstreamTokenProvider = (options?: {
signal?: AbortSignal;
}) => Promise<OIDCTokens | null>;
+/** Target resolved from server configuration after the OBO trust check. Scopes are not an audience. */
+export interface UpstreamTokenTarget {
+ readonly mcpServer: string;
+ readonly scopes: string;
+}
+
/** Lazily supplies a renewable upstream-token provider when an OBO server actually needs one. */
export type UpstreamTokenProviderResolver = (options?: {
signal?: AbortSignal;
+ target?: UpstreamTokenTarget;
}) => UpstreamTokenProvider | undefined | Promise<UpstreamTokenProvider | undefined>;
/** Scheduled OBO credentials must not replace the browser's direct-bearer source. */
@@ -90,6 +97,7 @@ export async function awaitOboOperation<T>(
export function createLazyOboUpstreamTokenProvider(
resolver: UpstreamTokenProviderResolver,
signal?: AbortSignal,
+ target?: UpstreamTokenTarget,
): UpstreamTokenProvider {
let pending: Promise<UpstreamTokenProvider | undefined> | undefined;
return async (options) => {
@@ -99,7 +107,7 @@ export function createLazyOboUpstreamTokenProvider(
pending ??= Promise.resolve()
.then(() => {
effectiveSignal?.throwIfAborted();
- return resolver({ signal: effectiveSignal });
+ return resolver({ signal: effectiveSignal, ...(target ? { target } : {}) });
})
.catch((error) => {
pending = undefined;
diff --git a/packages/api/src/schedules/README.md b/packages/api/src/schedules/README.md
index 408641fa6d..e155a4b402 100644
--- a/packages/api/src/schedules/README.md
+++ b/packages/api/src/schedules/README.md
@@ -38,3 +38,45 @@ messages or OAuth URLs. Successful dispatch records also retain the server outco
The schedule card shows failed servers and links to the selected agent for recovery.
A pure pause remains available even when MCP validation fails. This change does not
re-enable existing schedules automatically or repair credentials on the user's behalf.
+
+## Host token-provider context
+
+`createMCPPreflight` and `createInitializeClient` accept a
+`HostUpstreamTokenProviderResolver`. The default application does not install one.
+The host receives the persisted/authenticated user and these optional fields:
+
+```ts
+resolveUpstreamTokenProvider(user, {
+ signal,
+ context: { scheduleId, ownerId, tenantId, agentId, invocationMode: 'delegated' },
+ target: { mcpServer, scopes },
+});
+```
+
+Admission allocates a proposed schedule ID before preflight and persists that same ID
+only if creation succeeds. Preflight is validation, not a provisioning/consent hook:
+hosts must not create durable grants keyed by this proposed ID. Failed admission or a
+concurrent idempotency-key winner can discard it. Edits
+and dispatch use the existing schedule ID. Execution derives the context from the
+verified schedule trigger and authenticated owner, then captures it before tool loading.
+`agentId` identifies the root scheduled agent throughout child execution and handoffs.
+After an approval pause, the resume host restores the context from the saved job after
+validating ownership, tenancy, agent identity, and schedule liveness. An explicit initializer
+argument carries this restored context; resume body fields cannot replace it.
+The existing resolver closure is passed through tool discovery, execution, and reconnects;
+it never goes into tool arguments or durable job payloads.
+
+Each OBO consumer supplies its server name and configured scopes after its existing trust
+check. A run shares in-flight lookups and successful providers only for identical server
+and scope pairs. Failed or empty lookups may retry; cancellation belongs to the owning run,
+so cancelling one child does not cancel a sibling's lookup.
+
+`tenantId` is absent in deployments without tenancy. `context` is absent for legacy callers
+that supply no schedule ID or verified trigger, and `target` is absent for legacy consumers.
+Existing callbacks may ignore the new fields. Hosts needing either field must reject its
+absence. Context describes execution; it is not a consent grant or permission to mint.
+Current schedules execute with their owner's authority, hence `delegated`. Dedicated agent
+authorization requires a separate implementation. Scopes are not an STS audience; audience
+mapping and authorization remain the host's responsibility.
+
+This interface adds no token store, STS exchange, consent API, or new MCP credential mode.
diff --git a/packages/api/src/schedules/context.spec.ts b/packages/api/src/schedules/context.spec.ts
new file mode 100644
index 0000000000..494922feea
--- /dev/null
+++ b/packages/api/src/schedules/context.spec.ts
@@ -0,0 +1,158 @@
+import type { IUser } from '@librechat/data-schemas';
+import type { ScheduledTokenContext } from './context';
+import {
+ bindUpstreamTokenProviderResolver,
+ createScheduleUpstreamTokenProviderResolver,
+} from './mcp';
+import { createLazyOboUpstreamTokenProvider } from '../mcp/oauth/obo';
+import { restoreScheduledTokenContext } from './context';
+
+const user = { id: 'owner', tenantId: 'tenant' } as IUser;
+const context: ScheduledTokenContext = {
+ scheduleId: 'schedule',
+ ownerId: 'owner',
+ tenantId: 'tenant',
+ agentId: 'root-agent',
+ invocationMode: 'delegated',
+};
+const target = { mcpServer: 'warehouse', scopes: 'api://warehouse/.default' };
+
+function request(manual = false) {
+ return {
+ user,
+ _isAgentTrigger: true,
+ body: {
+ agent_id: 'root-agent',
+ scheduleId: 'spoofed',
+ agentTrigger: {
+ version: 1,
+ event: {
+ type: 'schedule.occurrence',
+ occurredAt: 0,
+ source: { type: 'schedule', id: 'schedule' },
+ },
+ metadata: { manual },
+ },
+ },
+ };
+}
+
+it.each([false, true])('captures verified root identity for manual=%s', async (manual) => {
+ const req = request(manual);
+ const provider = jest.fn().mockResolvedValue({ access_token: 'token' });
+ const resolve = jest.fn().mockResolvedValue(provider);
+ const signal = new AbortController().signal;
+ const bound = createScheduleUpstreamTokenProviderResolver(req, resolve, signal)!;
+ req.body.agent_id = 'child-agent';
+ req.body.agentTrigger.event.source.id = 'changed';
+ await createLazyOboUpstreamTokenProvider(bound, signal, target)();
+ expect(resolve).toHaveBeenCalledWith(user, { signal, context, target });
+ expect(Object.isFrozen(resolve.mock.calls[0][1].context)).toBe(true);
+});
+
+it('ignores copied schedule metadata on an ordinary interactive request', () => {
+ const resolve = jest.fn();
+ expect(
+ createScheduleUpstreamTokenProviderResolver({ ...request(), _isAgentTrigger: false }, resolve),
+ ).toBeUndefined();
+ expect(resolve).not.toHaveBeenCalled();
+});
+
+it('leaves context absent for legacy schedule classification without verified metadata', async () => {
+ const resolve = jest.fn().mockResolvedValue(jest.fn());
+ const bound = createScheduleUpstreamTokenProviderResolver(
+ { ...request(), _isAgentTrigger: false, _isScheduledFire: true },
+ resolve,
+ )!;
+ await bound();
+ expect(resolve).toHaveBeenCalledWith(user, { signal: undefined });
+});
+
+it('shares lookup for sibling consumers and reconnects, but isolates server and scope changes', async () => {
+ const resolve = jest.fn(async () => jest.fn(async () => ({ access_token: 'token' })));
+ const bound = bindUpstreamTokenProviderResolver(user, resolve, undefined, context)!;
+ const targets = [
+ target,
+ target,
+ { ...target, mcpServer: 'second' },
+ { ...target, scopes: 'read' },
+ ];
+ await Promise.all(
+ targets.map((item) => createLazyOboUpstreamTokenProvider(bound, undefined, item)()),
+ );
+ expect(resolve).toHaveBeenCalledTimes(3);
+ await createLazyOboUpstreamTokenProvider(bound, undefined, target)({ forceRefresh: true });
+ expect(resolve).toHaveBeenCalledTimes(3);
+});
+
+it('isolates provider caches between schedules and retries only the failed target', async () => {
+ const resolve = jest
+ .fn()
+ .mockRejectedValueOnce(new Error('temporary'))
+ .mockResolvedValue(jest.fn());
+ const first = bindUpstreamTokenProviderResolver(user, resolve, undefined, context)!;
+ const second = bindUpstreamTokenProviderResolver(user, resolve, undefined, {
+ ...context,
+ scheduleId: 'second',
+ })!;
+ await expect(first({ target })).rejects.toThrow('temporary');
+ await second({ target });
+ await first({ target });
+ await first({ target });
+ expect(resolve).toHaveBeenCalledTimes(3);
+ expect(resolve.mock.calls[1][1].context.scheduleId).toBe('second');
+ expect(resolve.mock.calls[2][1].context.scheduleId).toBe('schedule');
+});
+
+it('restores a paused run from job identity without trusting resume body fields', async () => {
+ const req = {
+ user,
+ _isScheduledFire: true,
+ body: { scheduleId: 'spoofed', agent_id: 'spoofed' },
+ };
+ const restored = restoreScheduledTokenContext(req, {
+ userId: 'owner',
+ tenantId: 'tenant',
+ scheduleId: 'schedule',
+ agent_id: 'root-agent',
+ });
+ const resolve = jest.fn().mockResolvedValue(jest.fn());
+ await createScheduleUpstreamTokenProviderResolver(req, resolve, undefined, restored)!({ target });
+ expect(resolve).toHaveBeenCalledWith(user, { signal: undefined, context, target });
+ expect(JSON.stringify(req)).not.toContain('root-agent');
+});
+
+it.each([{ userId: 'different' }, { tenantId: 'different' }])(
+ 'rejects invalid restored identity %j',
+ (override) => {
+ expect(() =>
+ restoreScheduledTokenContext(
+ { user },
+ {
+ userId: 'owner',
+ tenantId: 'tenant',
+ scheduleId: 'schedule',
+ agent_id: 'root-agent',
+ ...override,
+ },
+ ),
+ ).toThrow('Scheduled job identity');
+ },
+);
+
+it.each([{ agent_id: undefined }, { tenantId: undefined }])(
+ 'leaves legacy job context absent for %j',
+ async (override) => {
+ const req = { user, _isScheduledFire: true };
+ const restored = restoreScheduledTokenContext(req, {
+ userId: 'owner',
+ tenantId: 'tenant',
+ scheduleId: 'schedule',
+ agent_id: 'root-agent',
+ ...override,
+ });
+ const resolve = jest.fn().mockResolvedValue(jest.fn());
+ await createScheduleUpstreamTokenProviderResolver(req, resolve, undefined, restored)!();
+ expect(resolve).toHaveBeenCalledWith(user, { signal: undefined });
+ },
+);
diff --git a/packages/api/src/schedules/context.ts b/packages/api/src/schedules/context.ts
new file mode 100644
index 0000000000..0c2393bbc7
--- /dev/null
+++ b/packages/api/src/schedules/context.ts
@@ -0,0 +1,38 @@
+/** Root actor for an owner-authorized schedule, preserved across subagents and handoffs. */
+export interface ScheduledTokenContext {
+ readonly scheduleId: string;
+ readonly ownerId: string;
+ readonly tenantId?: string;
+ readonly agentId: string;
+ readonly invocationMode: 'delegated';
+}
+
+interface ScheduleJobIdentity {
+ userId?: string;
+ tenantId?: string;
+ scheduleId?: string;
+ agent_id?: string;
+}
+
+/** Called by the resume host after job ownership, tenant, agent, and schedule checks. */
+export function restoreScheduledTokenContext(
+ req: { user: { id: string; tenantId?: string } },
+ metadata?: ScheduleJobIdentity,
+): ScheduledTokenContext | undefined {
+ if (!metadata?.scheduleId) return;
+ if (
+ metadata.userId !== req.user.id ||
+ (metadata.tenantId != null && metadata.tenantId !== req.user.tenantId)
+ ) {
+ throw new Error('Scheduled job identity does not match the authenticated owner.');
+ }
+ /** Legacy jobs remain resumable, but cannot claim a complete minting context. */
+ if (!metadata.agent_id || (req.user.tenantId && metadata.tenantId == null)) return;
+ return Object.freeze({
+ scheduleId: metadata.scheduleId,
+ ownerId: metadata.userId,
+ ...(metadata.tenantId ? { tenantId: metadata.tenantId } : {}),
+ agentId: metadata.agent_id,
+ invocationMode: 'delegated',
+ });
+}
diff --git a/packages/api/src/schedules/fire.spec.ts b/packages/api/src/schedules/fire.spec.ts
index c01138a2b2..a2073f5f50 100644
--- a/packages/api/src/schedules/fire.spec.ts
+++ b/packages/api/src/schedules/fire.spec.ts
@@ -949,7 +949,11 @@ it('bounds MCP preflight by the claim lease and the stricter concurrency config'
expect(preflightMCP).toHaveBeenCalledWith(
'agent-1',
OWNER,
- expect.objectContaining({ concurrency: 2, deadlineMs: leaseUntil.getTime() }),
+ expect.objectContaining({
+ scheduleId: 'sched-1',
+ concurrency: 2,
+ deadlineMs: leaseUntil.getTime(),
+ }),
);
});
diff --git a/packages/api/src/schedules/fire.ts b/packages/api/src/schedules/fire.ts
index a8cea11411..64f63a8bdb 100644
--- a/packages/api/src/schedules/fire.ts
+++ b/packages/api/src/schedules/fire.ts
@@ -448,6 +448,7 @@ export async function fireSchedule(
Date.now() +
Math.min(ownerLimits.mcpPreflightTimeoutMs, deploymentLimits.mcpPreflightTimeoutMs);
mcp = await deps.preflightMCP(schedule.agent_id, user, {
+ scheduleId: schedule.id,
signal: options?.signal,
concurrency: Math.min(
ownerLimits.mcpPreflightConcurrency,
diff --git a/packages/api/src/schedules/handlers.spec.ts b/packages/api/src/schedules/handlers.spec.ts
index 7afc4dcdf1..787b19fbf2 100644
--- a/packages/api/src/schedules/handlers.spec.ts
+++ b/packages/api/src/schedules/handlers.spec.ts
@@ -264,6 +264,11 @@ describe('createSchedule late-create compensation', () => {
const inserted = (deps.methods.createScheduleWithSlot as jest.Mock).mock.calls[0][0];
expect(inserted.nextRunAt).toBeUndefined();
+ expect(deps.preflightMCP).toHaveBeenCalledWith(
+ CREATE_BODY.agent_id,
+ expect.objectContaining({ id: 'user-1' }),
+ expect.objectContaining({ scheduleId: inserted.id }),
+ );
// And it is never armed afterwards, because the barrier refused the create.
expect(deps.methods.updateScheduleById).not.toHaveBeenCalled();
});
@@ -1185,6 +1190,11 @@ describe('updateSchedule re-enable attachment revalidation', () => {
await createSchedulesHandlers(deps).updateSchedule(makeReEnableReq(), res);
expect(markFilesUsed).toHaveBeenCalledWith(['file-a', 'file-b'], 'user-1');
+ expect(deps.preflightMCP).toHaveBeenCalledWith(
+ expect.any(String),
+ expect.objectContaining({ id: 'user-1', tenantId: 't1' }),
+ expect.objectContaining({ scheduleId: 'sched-1' }),
+ );
expect(captured.status ?? 200).toBe(200);
expect(deps.methods.updateScheduleById).toHaveBeenCalled();
});
diff --git a/packages/api/src/schedules/handlers.ts b/packages/api/src/schedules/handlers.ts
index 2468ca4ed9..1d30f50ca2 100644
--- a/packages/api/src/schedules/handlers.ts
+++ b/packages/api/src/schedules/handlers.ts
@@ -387,9 +387,11 @@ export function createSchedulesHandlers(deps: SchedulesHandlersDeps): SchedulesH
res: Response,
signal: AbortSignal,
limits: ScheduleLimits,
+ scheduleId: string,
): Promise<boolean> {
try {
await deps.preflightMCP(agentId, requestUser(req), {
+ scheduleId,
signal,
concurrency: limits.mcpPreflightConcurrency,
deadlineMs: Date.now() + limits.mcpPreflightTimeoutMs,
@@ -705,9 +707,10 @@ export function createSchedulesHandlers(deps: SchedulesHandlersDeps): SchedulesH
await respondToReplay(replayed);
return;
}
+ const id = `sched_${randomUUID()}`;
if (
parsed.data.enabled &&
- !(await validateMCP(parsed.data.agent_id, req, res, mcpSignal, limits))
+ !(await validateMCP(parsed.data.agent_id, req, res, mcpSignal, limits, id))
)
return;
// Project policy applies to a NEW insert only, and is therefore resolved AFTER every
@@ -751,7 +754,6 @@ export function createSchedulesHandlers(deps: SchedulesHandlersDeps): SchedulesH
if (!withinIntervalFloor(res, parsed.data.cadence, parsed.data.timezone, limits)) {
return;
}
- const id = `sched_${randomUUID()}`;
const nextRunAt = parsed.data.enabled
? computeNextRunAt({
cadence: parsed.data.cadence,
@@ -972,7 +974,14 @@ export function createSchedulesHandlers(deps: SchedulesHandlersDeps): SchedulesH
}
if (
enabled &&
- !(await validateMCP(parsed.data.agent_id ?? existing.agent_id, req, res, mcpSignal, limits))
+ !(await validateMCP(
+ parsed.data.agent_id ?? existing.agent_id,
+ req,
+ res,
+ mcpSignal,
+ limits,
+ existing.id,
+ ))
)
return;
// The destination is re-resolved on every edit that leaves the schedule ENABLED,
diff --git a/packages/api/src/schedules/index.ts b/packages/api/src/schedules/index.ts
index bd702113d7..709c9a6cfd 100644
--- a/packages/api/src/schedules/index.ts
+++ b/packages/api/src/schedules/index.ts
@@ -1,5 +1,6 @@
export * from './access';
export * from './cadence';
+export * from './context';
export * from './engine';
export * from './erasure';
export * from './fire';
diff --git a/packages/api/src/schedules/mcp.spec.ts b/packages/api/src/schedules/mcp.spec.ts
index 4def3a3d6c..35c20b47c1 100644
--- a/packages/api/src/schedules/mcp.spec.ts
+++ b/packages/api/src/schedules/mcp.spec.ts
@@ -93,8 +93,13 @@ function setup(tools = ['search_mcp_docs']) {
disconnect,
check: (
agentId: string,
- user: typeof principal,
- options?: { concurrency?: number; signal?: AbortSignal; deadlineMs?: number },
+ user: typeof principal & { tenantId?: string },
+ options?: {
+ concurrency?: number;
+ signal?: AbortSignal;
+ deadlineMs?: number;
+ scheduleId?: string;
+ },
) => preflight(agentId, user, { concurrency: 3, ...options }),
};
}
@@ -157,6 +162,36 @@ it('does not resolve upstream credentials for non-OBO servers', async () => {
expect(deps.resolveUpstreamTokenProvider).not.toHaveBeenCalled();
});
+it('passes admission identity to the host and rejects a changed tenant before connection', async () => {
+ const { check, deps } = setup();
+ const user = { ...principal, tenantId: 'tenant' };
+ deps.getUser = jest.fn(async () => user as IUser);
+ deps.resolveUpstreamTokenProvider = jest.fn(async () =>
+ jest.fn(async () => ({ access_token: 'token' })),
+ );
+ const connect = deps.connect;
+ deps.connect = jest.fn(async (options) => {
+ await options.upstreamTokenProviderResolver?.();
+ return connect(options);
+ });
+ await check('agent', user, { scheduleId: 'schedule' });
+ expect(deps.resolveUpstreamTokenProvider).toHaveBeenCalledWith(user, {
+ signal: undefined,
+ context: {
+ scheduleId: 'schedule',
+ ownerId: 'owner',
+ tenantId: 'tenant',
+ agentId: 'agent',
+ invocationMode: 'delegated',
+ },
+ });
+ jest.mocked(deps.connect).mockClear();
+ await expect(
+ check('agent', { ...user, tenantId: 'different' }, { scheduleId: 'schedule' }),
+ ).rejects.toBeInstanceOf(ScheduleMCPError);
+ expect(deps.connect).not.toHaveBeenCalled();
+});
+
it('does not expose an OBO provider to a sibling direct-bearer server', async () => {
const { check, deps } = setup(['search_mcp_obo', 'search_mcp_direct']);
deps.getServerConfigs = jest.fn(async () => ({
diff --git a/packages/api/src/schedules/mcp.ts b/packages/api/src/schedules/mcp.ts
index 63a7e4f8db..37d3a34489 100644
--- a/packages/api/src/schedules/mcp.ts
+++ b/packages/api/src/schedules/mcp.ts
@@ -22,11 +22,16 @@ import type {
AgentGraphAccessContext,
} from '@librechat/data-schemas';
import type { TModelsConfig, ScheduleMCPStatus, ScheduleMCPOutcome } from 'librechat-data-provider';
-import type { UpstreamTokenProvider, UpstreamTokenProviderResolver } from '../mcp/oauth/obo';
+import type {
+ UpstreamTokenProvider,
+ UpstreamTokenProviderResolver,
+ UpstreamTokenTarget,
+} from '../mcp/oauth/obo';
import type { ParsedServerConfig, UserMCPConnectionOptions } from '../mcp/types';
import type { CheckAccessParams } from '../middleware/access';
import type { MCPToolsSnapshot } from '../mcp/connection';
import type { GetAppConfigOptions } from '../app/service';
+import type { ScheduledTokenContext } from './context';
import type { ScheduleMCPPreflight } from './types';
import {
MCPAuthenticationRejectedError,
@@ -41,6 +46,7 @@ import {
} from '../mcp/utils';
import { MCPConfigInitializationCanceledError } from '../mcp/registry/MCPServersRegistry';
import { createMCPRequestContext, cleanupMCPRequestContext } from '../mcp/request';
+import { isScheduleFireRequest, readScheduleFireContext } from './trigger';
import { getAppConfigOptionsFromUser } from '../app/service';
import { createConcurrencyLimiter } from '../utils/promise';
import { OboTokenResolutionError } from '../mcp/oauth/obo';
@@ -50,48 +56,85 @@ import { formatMCPServerTools } from '../mcp/tools';
import { checkAccess } from '../middleware/access';
import { detachOnAbort } from '../utils/promises';
import { getPluginAuthMap } from '../agents/auth';
-import { isScheduleFireRequest } from './trigger';
-type HostUpstreamTokenProviderResolver = (
- user: IUser,
- options: { signal?: AbortSignal },
+export interface ScheduledTokenIdentity {
+ readonly id: string;
+ readonly tenantId?: string;
+ readonly role?: string;
+ readonly provider?: string;
+ readonly openidId?: string;
+ readonly openidIssuer?: string;
+}
+
+export type HostUpstreamTokenProviderResolver = (
+ user: ScheduledTokenIdentity,
+ options: {
+ signal?: AbortSignal;
+ context?: ScheduledTokenContext;
+ target?: UpstreamTokenTarget;
+ },
) => ReturnType<UpstreamTokenProviderResolver>;
/** Bind a credential lookup to the trusted principal and owning run's cancellation. */
export function bindUpstreamTokenProviderResolver(
- user: IUser,
+ user: ScheduledTokenIdentity,
resolve: HostUpstreamTokenProviderResolver | undefined,
signal?: AbortSignal,
+ context?: ScheduledTokenContext,
): UpstreamTokenProviderResolver | undefined {
if (!resolve) return undefined;
- let pending: Promise<UpstreamTokenProvider | undefined> | undefined;
- return () => {
+ const capturedContext = context && Object.freeze({ ...context });
+ const pending = new Map<string, Promise<UpstreamTokenProvider | undefined>>();
+ return (options) => {
signal?.throwIfAborted();
- pending ??= Promise.resolve()
+ const target = options?.target && Object.freeze({ ...options.target });
+ const key = JSON.stringify([target?.mcpServer, target?.scopes]);
+ const cached = pending.get(key);
+ if (cached) return cached;
+ const lookup = Promise.resolve()
.then(() => {
signal?.throwIfAborted();
- return resolve(user, { signal });
+ return resolve(user, {
+ signal,
+ ...(capturedContext ? { context: capturedContext } : {}),
+ ...(target ? { target } : {}),
+ });
})
.then((provider) => {
- if (!provider) pending = undefined;
+ if (!provider) pending.delete(key);
return provider;
})
.catch((error) => {
- pending = undefined;
+ pending.delete(key);
throw error;
});
- return pending;
+ pending.set(key, lookup);
+ return lookup;
};
}
export function createScheduleUpstreamTokenProviderResolver(
- req: Parameters<typeof isScheduleFireRequest>[0] & { user: IUser },
+ req: Parameters<typeof isScheduleFireRequest>[0] & { user: ScheduledTokenIdentity },
resolve: HostUpstreamTokenProviderResolver | undefined,
signal?: AbortSignal,
+ restoredContext?: ScheduledTokenContext,
): UpstreamTokenProviderResolver | undefined {
- return isScheduleFireRequest(req)
- ? bindUpstreamTokenProviderResolver(req.user, resolve, signal)
- : undefined;
+ if (!isScheduleFireRequest(req)) return undefined;
+ if (restoredContext)
+ return bindUpstreamTokenProviderResolver(req.user, resolve, signal, restoredContext);
+ const fire = readScheduleFireContext(req);
+ const agentId = req.body?.agent_id;
+ const context: ScheduledTokenContext | undefined =
+ fire && typeof agentId === 'string' && agentId.trim().length > 0
+ ? {
+ scheduleId: fire.scheduleId,
+ ownerId: req.user.id,
+ ...(req.user.tenantId ? { tenantId: req.user.tenantId } : {}),
+ agentId,
+ invocationMode: 'delegated',
+ }
+ : undefined;
+ return bindUpstreamTokenProviderResolver(req.user, resolve, signal, context);
}
// The public schedule schema caps mcpPreflightConcurrency at 10. Keep the same
@@ -145,10 +188,7 @@ interface ScheduleMCPDeps {
role?: string,
) => Promise<Record<string, ParsedServerConfig>>;
findPluginAuthsByKeys: PluginAuthMethods['findPluginAuthsByKeys'];
- resolveUpstreamTokenProvider?: (
- user: IUser,
- options: { signal?: AbortSignal },
- ) => UpstreamTokenProvider | undefined | Promise<UpstreamTokenProvider | undefined>;
+ resolveUpstreamTokenProvider?: HostUpstreamTokenProviderResolver;
connect: (options: UserMCPConnectionOptions) => Promise<{
fetchToolsSnapshot: (deadlineMs?: number, signal?: AbortSignal) => Promise<MCPToolsSnapshot>;
}>;
@@ -165,7 +205,7 @@ export function createScheduleMCPPreflight(deps: ScheduleMCPDeps): ScheduleMCPPr
throwIfAborted();
const user = await deps.getUser(principal.id);
throwIfAborted();
- if (!user) throw new ScheduleMCPError([]);
+ if (!user || user.tenantId !== principal.tenantId) throw new ScheduleMCPError([]);
user.id = principal.id;
let appConfig: AppConfig | undefined;
const loadAppConfig = async (): Promise<AppConfig | undefined> => {
@@ -624,6 +664,15 @@ export function createScheduleMCPPreflight(deps: ScheduleMCPDeps): ScheduleMCPPr
user,
deps.resolveUpstreamTokenProvider,
options.signal,
+ options.scheduleId
+ ? {
+ scheduleId: options.scheduleId,
+ ownerId: principal.id,
+ ...(user.tenantId ? { tenantId: user.tenantId } : {}),
+ agentId,
+ invocationMode: 'delegated',
+ }
+ : undefined,
);
throwIfAborted();
const requestBody = {
diff --git a/packages/api/src/schedules/types.ts b/packages/api/src/schedules/types.ts
index 6f3f29ba1c..1e4c659a3f 100644
--- a/packages/api/src/schedules/types.ts
+++ b/packages/api/src/schedules/types.ts
@@ -329,5 +329,5 @@ export type FireableSchedule = ISchedule;
export type ScheduleMCPPreflight = (
agentId: string,
user: ScheduleUserContext,
- options: { concurrency: number; signal?: AbortSignal; deadlineMs?: number },
+ options: { concurrency: number; signal?: AbortSignal; deadlineMs?: number; scheduleId?: string },
) => Promise<ScheduleMCPOutcome[]>;