From 21a9edbe7481fd4de180b45922a2468fdcf79ea3 Mon Sep 17 00:00:00 2001 From: Danny Avila Date: Tue, 15 Sep 2026 10:46:13 -0400 Subject: [PATCH] =?UTF-8?q?=F0=9F=AA=AA=20feat:=20Pass=20Schedule=20Identi?= =?UTF-8?q?ty=20to=20MCP=20Token=20Providers=20(#15962)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: carry schedule context into MCP token providers * fix: restore scheduled token context after approval pauses * fix: make scheduled identity boundaries explicit * test: keep owner-drain leases live through CI delays --- .../agents/__tests__/resume.spec.js | 7 + api/server/controllers/agents/resume.js | 2 + .../services/Endpoints/agents/initialize.js | 3 +- .../Endpoints/agents/initialize.spec.js | 30 +++- api/server/services/Schedules/mcp.js | 2 +- .../api/src/agents/subagentThreads.spec.ts | 7 +- packages/api/src/mcp/MCPConnectionFactory.ts | 1 + packages/api/src/mcp/MCPManager.ts | 1 + .../__tests__/MCPConnectionFactory.test.ts | 5 + .../api/src/mcp/__tests__/MCPManager.test.ts | 5 + packages/api/src/mcp/oauth/obo.ts | 10 +- packages/api/src/schedules/README.md | 42 +++++ packages/api/src/schedules/context.spec.ts | 158 ++++++++++++++++++ packages/api/src/schedules/context.ts | 38 +++++ packages/api/src/schedules/fire.spec.ts | 6 +- packages/api/src/schedules/fire.ts | 1 + packages/api/src/schedules/handlers.spec.ts | 10 ++ packages/api/src/schedules/handlers.ts | 15 +- packages/api/src/schedules/index.ts | 1 + packages/api/src/schedules/mcp.spec.ts | 39 ++++- packages/api/src/schedules/mcp.ts | 93 ++++++++--- packages/api/src/schedules/types.ts | 2 +- 22 files changed, 442 insertions(+), 36 deletions(-) create mode 100644 packages/api/src/schedules/context.spec.ts create mode 100644 packages/api/src/schedules/context.ts 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} [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} [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; +/** 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; /** Scheduled OBO credentials must not replace the browser's direct-bearer source. */ @@ -90,6 +97,7 @@ export async function awaitOboOperation( export function createLazyOboUpstreamTokenProvider( resolver: UpstreamTokenProviderResolver, signal?: AbortSignal, + target?: UpstreamTokenTarget, ): UpstreamTokenProvider { let pending: Promise | 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 { 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; /** 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 | undefined; - return () => { + const capturedContext = context && Object.freeze({ ...context }); + const pending = new Map>(); + 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[0] & { user: IUser }, + req: Parameters[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>; findPluginAuthsByKeys: PluginAuthMethods['findPluginAuthsByKeys']; - resolveUpstreamTokenProvider?: ( - user: IUser, - options: { signal?: AbortSignal }, - ) => UpstreamTokenProvider | undefined | Promise; + resolveUpstreamTokenProvider?: HostUpstreamTokenProviderResolver; connect: (options: UserMCPConnectionOptions) => Promise<{ fetchToolsSnapshot: (deadlineMs?: number, signal?: AbortSignal) => Promise; }>; @@ -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 => { @@ -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;