Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

5.5 KB
Raw Blame
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 });
  },
);