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

8.1 KB
Raw Blame
import React from 'react';
import { QueryKeys } from 'librechat-data-provider';
import { act, render, waitFor } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import type { ParentSubagentIndex, ParentSubagentSummary } from 'librechat-data-provider';
import { ParentSubagentsProvider, useParentSubagents } from './ParentSubagentsProvider';

const mockUseParentSubagentsQuery = jest.fn();

const renderProvider = (element: React.ReactElement, client = new QueryClient()) =>
  render(element, {
    wrapper: ({ children }) => (
      <QueryClientProvider client={client}>{children}</QueryClientProvider>
    ),
  });

jest.mock('~/data-provider', () => ({
  useParentSubagentsQuery: (...args: unknown[]) => mockUseParentSubagentsQuery(...args),
}));

const eventChild: ParentSubagentSummary = {
  threadId: 'event-thread',
  parentMessageId: 'parent-message',
  subagentType: 'agent-1',
  subagentKind: 'agent',
  title: 'Event child',
  origin: 'event',
  actorId: 'actor-a',
  status: 'completed',
  latestTaskId: 'task-1',
  tasks: [{ taskId: 'task-1', status: 'completed' }],
  tasksTruncated: false,
};
const toolChild: ParentSubagentSummary = {
  ...eventChild,
  threadId: 'tool-thread',
  parentToolCallId: 'tool-call',
  origin: 'tool',
  actorId: undefined,
};

describe('ParentSubagentsProvider', () => {
  it('reconstructs event groups from one durable conversation query and refreshes that index', async () => {
    const refreshed: ParentSubagentIndex = {
      parentConversationId: 'parent-conversation',
      children: [{ ...eventChild, latestTaskId: 'task-2' }],
      childrenTruncated: false,
    };
    const refetch = jest.fn().mockResolvedValue({ data: refreshed });
    mockUseParentSubagentsQuery.mockReturnValue({
      data: {
        parentConversationId: 'parent-conversation',
        children: [eventChild, toolChild],
        childrenTruncated: false,
      },
      refetch,
    });
    let context: ReturnType<typeof useParentSubagents> | undefined;
    const Probe = () => {
      context = useParentSubagents();
      return null;
    };

    renderProvider(
      <ParentSubagentsProvider conversationId="parent-conversation" enabled>
        <Probe />
      </ParentSubagentsProvider>,
    );

    expect(mockUseParentSubagentsQuery).toHaveBeenCalledWith(
      'parent-conversation',
      { enabled: true },
      false,
    );
    expect(context?.byMessageId.get('parent-message')).toEqual([eventChild]);
    expect(context?.byThreadId.get('tool-thread')).toEqual(toolChild);
    let result: ParentSubagentIndex | undefined;
    await act(async () => {
      result = await context?.refresh();
    });
    expect(refetch).toHaveBeenCalledTimes(1);
    expect(result).toEqual(refreshed);
  });

  it('reuses its parent index while chats match and owns discovery after navigation', () => {
    mockUseParentSubagentsQuery.mockImplementation((conversationId: string) => ({
      data: {
        parentConversationId: conversationId,
        children: conversationId === 'parent-conversation' ? [eventChild] : [],
        childrenTruncated: false,
      },
      refetch: jest.fn(),
    }));
    let outer: ReturnType<typeof useParentSubagents> | undefined;
    let panel: ReturnType<typeof useParentSubagents> | undefined;
    const OuterProbe = () => {
      outer = useParentSubagents();
      return null;
    };
    const PanelProbe = () => {
      panel = useParentSubagents();
      return null;
    };
    const tree = (visibleConversation: string) => (
      <ParentSubagentsProvider conversationId={visibleConversation} enabled>
        <OuterProbe />
        <ParentSubagentsProvider conversationId="parent-conversation" enabled>
          <PanelProbe />
        </ParentSubagentsProvider>
      </ParentSubagentsProvider>
    );
    const view = renderProvider(tree('parent-conversation'));
    expect(panel).toBe(outer);
    expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(
      'parent-conversation',
      { enabled: false },
      false,
    );
    view.rerender(tree('other-conversation'));
    expect(panel?.conversationId).toBe('parent-conversation');
    expect(panel?.byThreadId.get('event-thread')).toEqual(eventChild);
    expect(outer?.conversationId).toBe('other-conversation');
    expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(
      'parent-conversation',
      { enabled: true },
      false,
    );
  });

  it('marks an active parent run for prompt discovery', () => {
    mockUseParentSubagentsQuery.mockReturnValue({ data: undefined, refetch: jest.fn() });
    renderProvider(
      <ParentSubagentsProvider conversationId="parent-conversation" enabled isSubmitting>
        <div />
      </ParentSubagentsProvider>,
    );
    expect(mockUseParentSubagentsQuery).toHaveBeenCalledWith(
      'parent-conversation',
      { enabled: true },
      true,
    );
  });

  it('retains discovery on endpoint switches but resets for a different conversation', () => {
    mockUseParentSubagentsQuery.mockReturnValue({ data: undefined, refetch: jest.fn() });
    const { rerender } = renderProvider(
      <ParentSubagentsProvider conversationId="agent-chat" enabled>
        <div />
      </ParentSubagentsProvider>,
    );
    rerender(
      <ParentSubagentsProvider conversationId="agent-chat" enabled={false}>
        <div />
      </ParentSubagentsProvider>,
    );
    expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(
      'agent-chat',
      { enabled: true },
      false,
    );
    rerender(
      <ParentSubagentsProvider conversationId="plain-chat" enabled={false}>
        <div />
      </ParentSubagentsProvider>,
    );
    expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(
      'plain-chat',
      { enabled: false },
      false,
    );
  });

  it.each(['history', 'tools', 'subagents'])(
    'restores discovery from cached %s after switching endpoints',
    (evidence) => {
      mockUseParentSubagentsQuery.mockReturnValue({ data: undefined, refetch: jest.fn() });
      const client = new QueryClient();
      if (evidence === 'history')
        client.setQueryData([QueryKeys.messages, 'restored'], [{ endpoint: 'agents' }]);
      if (evidence === 'tools')
        client.setQueryData([QueryKeys.backgroundTasks, 'restored'], { tasks: [{}] });
      if (evidence === 'subagents')
        client.setQueryData([QueryKeys.parentSubagents, 'restored'], { children: [eventChild] });
      renderProvider(
        <ParentSubagentsProvider conversationId="restored" enabled={false}>
          <div />
        </ParentSubagentsProvider>,
        client,
      );
      expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(
        'restored',
        { enabled: true },
        false,
      );
    },
  );

  it('does not discover tasks for a new or genuinely non-agent conversation', () => {
    mockUseParentSubagentsQuery.mockReturnValue({ data: undefined, refetch: jest.fn() });
    const { rerender } = renderProvider(
      <ParentSubagentsProvider conversationId="plain" enabled={false}>
        <div />
      </ParentSubagentsProvider>,
    );
    expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(
      'plain',
      { enabled: false },
      false,
    );
    rerender(
      <ParentSubagentsProvider conversationId="new" enabled>
        <div />
      </ParentSubagentsProvider>,
    );
    expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith('new', { enabled: false }, false);
  });

  it('starts discovery when agent history arrives after the initial render', async () => {
    mockUseParentSubagentsQuery.mockReturnValue({ data: undefined, refetch: jest.fn() });
    const client = new QueryClient();
    renderProvider(
      <ParentSubagentsProvider conversationId="restored" enabled={false}>
        <div />
      </ParentSubagentsProvider>,
      client,
    );
    expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(
      'restored',
      { enabled: false },
      false,
    );
    await act(async () => {
      client.setQueryData([QueryKeys.messages, 'restored'], [{ endpoint: 'agents' }]);
    });
    await waitFor(() =>
      expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(
        'restored',
        { enabled: true },
        false,
      ),
    );
  });
});