mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-18 22:14:27 +00:00
🪪 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:
parent
1df4484810
commit
21a9edbe74
22 changed files with 442 additions and 36 deletions
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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 });
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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 () => {
|
||||
|
|
|
|||
|
|
@ -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({
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -654,6 +654,7 @@ export class MCPConnectionFactory {
|
|||
this.upstreamTokenProvider = createLazyOboUpstreamTokenProvider(
|
||||
this.upstreamTokenProviderResolver,
|
||||
this.signal,
|
||||
{ mcpServer: this.serverName, scopes: oboConfig.scopes },
|
||||
);
|
||||
}
|
||||
if (!this.upstreamTokenProvider) {
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
158
packages/api/src/schedules/context.spec.ts
Normal file
158
packages/api/src/schedules/context.spec.ts
Normal 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 });
|
||||
},
|
||||
);
|
||||
38
packages/api/src/schedules/context.ts
Normal file
38
packages/api/src/schedules/context.ts
Normal 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',
|
||||
});
|
||||
}
|
||||
|
|
@ -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(),
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
});
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
export * from './access';
|
||||
export * from './cadence';
|
||||
export * from './context';
|
||||
export * from './engine';
|
||||
export * from './erasure';
|
||||
export * from './fire';
|
||||
|
|
|
|||
|
|
@ -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 () => ({
|
||||
|
|
|
|||
|
|
@ -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 = {
|
||||
|
|
|
|||
|
|
@ -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[]>;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue