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
🪪 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.tsindex 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.tsindex 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.tsindex 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 serveroboUpstreamTokenProvider = 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.tsindex 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.tsindex 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.tsindex 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.mdindex 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 outcoThe 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 notre-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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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): SchedulesHres: 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): SchedulesHawait 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): SchedulesHif (!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.tsindex 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.tsindex 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.tsindex 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): ScheduleMCPPrthrowIfAborted();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): ScheduleMCPPruser,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.tsindex 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[]>;