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

* 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
This commit is contained in:
Danny Avila 2026-09-15 10:46:13 -04:00 • committed by GitHub
parent 1df4484810
commit 21a9edbe74
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 442 additions and 36 deletions

View file

@ -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,

View file

@ -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,

View file

@ -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 });
};

View file

@ -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 () => {

View file

@ -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({

View file

@ -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);

View file

@ -654,6 +654,7 @@ export class MCPConnectionFactory {
this.upstreamTokenProvider = createLazyOboUpstreamTokenProvider(
this.upstreamTokenProviderResolver,
this.signal,
{ mcpServer: this.serverName, scopes: oboConfig.scopes },
);
}
if (!this.upstreamTokenProvider) {

View file

@ -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) {

View file

@ -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,

View file

@ -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,

View file

@ -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;

View file

@ -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.

View file

@ -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 });
},
);

View file

@ -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',
});
}

View file

@ -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(),
}),
);
});

View file

@ -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,

View file

@ -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();
});

View file

@ -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,

View file

@ -1,5 +1,6 @@
export * from './access';
export * from './cadence';
export * from './context';
export * from './engine';
export * from './erasure';
export * from './fire';

View file

@ -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 () => ({

View file

@ -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 = {

View file

@ -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[]>;