Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

24.4 KB
Raw Blame
// @vitest-environment jsdom
import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
import { describe, expect, it, vi } from 'vitest';

import { AgentSessionTimelineContainer } from '@/containers/AgentSessionTimelineContainer.js';
import { ServerProvider } from '@/server/ServerContext.js';
import type { SessionEventItem } from '@/server/types.js';
import { SlotsProvider } from '@/theme/SlotsProvider.js';
import { createMockAgentUIServer } from '../server/mockServer.js';

type TurnDoneEvent = Extract<SessionEventItem['event'], { type: 'turn.done' }>;

const events: SessionEventItem[] = [
  {
    turnId: 'turn-1',
    event: {
      type: 'turn.created',
      id: 'c1',
      turnId: 'turn-1',
      previousTurnId: null,
      input: [{ type: 'user.message', content: 'hello' }],
      state: { status: 'running' },
      createdAt: '2026-01-01T00:00:00.000Z',
      threadId: null,
    },
  },
  {
    turnId: 'turn-1',
    event: {
      type: 'turn.done',
      id: 'd1',
      state: { status: 'done', completedAt: '2026-01-01T00:00:02.000Z', output: null, requiredActions: [] },
      createdAt: '2026-01-01T00:00:02.000Z',
      threadId: null,
    },
  },
];

const doneState: TurnDoneEvent['state'] = {
  status: 'done',
  completedAt: '2026-01-01T00:00:02.000Z',
  output: null,
  requiredActions: [],
};

const groupingEvents: SessionEventItem[] = [
  {
    turnId: 'turn-1',
    event: {
      type: 'turn.created',
      id: 'turn-1-created',
      turnId: 'turn-1',
      previousTurnId: null,
      input: [{ type: 'user.message', content: 'initial request' }],
      state: { status: 'running' },
      createdAt: '2026-01-01T00:00:00.000Z',
      threadId: null,
    },
  },
  {
    turnId: 'turn-1',
    event: {
      type: 'model.message',
      id: 'turn-1-model',
      threadId: 'main',
      content: 'turn one response',
      createdAt: '2026-01-01T00:00:01.000Z',
    },
  },
  {
    turnId: 'turn-1',
    event: { type: 'turn.done', id: 'turn-1-done', state: doneState, createdAt: doneState.completedAt },
  },
  {
    turnId: 'turn-2',
    event: {
      type: 'turn.created',
      id: 'turn-2-created',
      turnId: 'turn-2',
      previousTurnId: 'turn-1',
      input: [{ type: 'user.tool_response', threadId: 'main', toolCallId: 'question-1', content: 'continue' }],
      state: { status: 'running' },
      createdAt: '2026-01-01T00:00:03.000Z',
      threadId: null,
    },
  },
  {
    turnId: 'turn-2',
    event: {
      type: 'model.message',
      id: 'turn-2-model',
      threadId: 'main',
      content: 'turn two response',
      createdAt: '2026-01-01T00:00:04.000Z',
    },
  },
  {
    turnId: 'turn-2',
    event: {
      type: 'turn.done',
      id: 'turn-2-done',
      state: { ...doneState, completedAt: '2026-01-01T00:00:05.000Z' },
      createdAt: '2026-01-01T00:00:05.000Z',
    },
  },
  {
    turnId: 'turn-3',
    event: {
      type: 'turn.created',
      id: 'turn-3-created',
      turnId: 'turn-3',
      previousTurnId: 'turn-2',
      input: [{ type: 'user.tool_response', threadId: 'main', toolCallId: 'question-2', content: 'stop' }],
      state: { status: 'running' },
      createdAt: '2026-01-01T00:00:06.000Z',
      threadId: null,
    },
  },
  {
    turnId: 'turn-3',
    event: {
      type: 'turn.done',
      id: 'turn-3-done',
      state: {
        status: 'cancelled',
        reason: 'client-cancelled',
        completedAt: '2026-01-01T00:00:07.000Z',
      },
      createdAt: '2026-01-01T00:00:07.000Z',
    },
  },
  {
    turnId: 'turn-4',
    event: {
      type: 'turn.created',
      id: 'turn-4-created',
      turnId: 'turn-4',
      previousTurnId: 'turn-3',
      input: [{ type: 'user.message', content: 'retry' }],
      state: { status: 'running' },
      createdAt: '2026-01-01T00:00:08.000Z',
      threadId: null,
    },
  },
  {
    turnId: 'turn-4',
    event: {
      type: 'turn.done',
      id: 'turn-4-done',
      state: { status: 'error', message: 'model failed', completedAt: '2026-01-01T00:00:09.000Z' },
      createdAt: '2026-01-01T00:00:09.000Z',
    },
  },
];

describe('AgentSessionTimelineContainer', () => {
  it('passes grouped turns to the timeline slot and scrolls on select', async () => {
    const scrollIntoView = vi.fn();
    HTMLElement.prototype.scrollIntoView = scrollIntoView;

    const { container } = render(
      <SlotsProvider
        overrides={{
          AgentSessionEventTimeline: ({ turns, onSelectTurn }) => (
            <button type="button" onClick={() => onSelectTurn?.(0)}>
              {`timeline turns=${turns.length}`}
            </button>
          ),
        }}
      >
        <ServerProvider server={createMockAgentUIServer()}>
          <AgentSessionTimelineContainer sessionId="sess-1" events={events} />
        </ServerProvider>
      </SlotsProvider>,
    );

    expect(await screen.findByText('timeline turns=1')).toBeInTheDocument();
    expect(await screen.findByText('Turn 1')).toBeInTheDocument();
    expect(screen.getByText('Turn')).toBeInTheDocument();
    const metricsStrip = container.querySelector('[data-slot="agent-session-metrics-sticky"]');
    expect(metricsStrip).toHaveTextContent('Duration');
    expect(await screen.findAllByRole('button', { name: 'Copy' })).not.toHaveLength(0);
    expect(container.querySelector('[data-slot="agent-session-scroll"]')).toHaveClass('overflow-y-auto');
    expect(container.querySelector('[data-slot="agent-session-metrics-sticky"]')).toHaveClass(
      'sticky',
      'top-0',
      'bg-primary-bg',
    );
    expect(container.querySelector('[data-slot="aui_thread-viewport"]')).toHaveClass('overflow-visible');
    fireEvent.click(screen.getByRole('button', { name: 'timeline turns=1' }));
    await waitFor(() => {
      expect(scrollIntoView).toHaveBeenCalled();
    });
  });

  it('shows the empty state when the only turn is still running', async () => {
    render(
      <SlotsProvider overrides={{ AgentSessionEventTimeline: () => null }}>
        <ServerProvider
          server={createMockAgentUIServer({
            listTurns: async () => ({
              data: [
                {
                  id: 'turn-running',
                  sessionId: 'sess-1',
                  state: { status: 'running' as const },
                  createdAt: '2026-01-01T00:00:00.000Z',
                  input: [{ type: 'user.message' as const, content: 'in flight' }],
                },
              ],
            }),
            getTurn: async () => ({
              id: 'turn-running',
              sessionId: 'sess-1',
              state: { status: 'running' as const },
              createdAt: '2026-01-01T00:00:00.000Z',
              input: [{ type: 'user.message' as const, content: 'in flight' }],
            }),
            listTurnEvents: async () => ({
              data: [
                {
                  type: 'model.message' as const,
                  id: 'm1',
                  threadId: 'main',
                  content: 'partial assistant text',
                  createdAt: '2026-01-01T00:00:01.000Z',
                },
              ],
            }),
          })}
        >
          <AgentSessionTimelineContainer sessionId="sess-1" events={[]} />
        </ServerProvider>
      </SlotsProvider>,
    );

    expect(await screen.findByText('This session has no messages yet.')).toBeInTheDocument();
    expect(screen.queryByText('in flight')).not.toBeInTheDocument();
    expect(screen.queryByText('partial assistant text')).not.toBeInTheDocument();
  });

  it('keeps responses in their backend turns and renders terminal failures', async () => {
    let timelineTitles: string[] = [];
    render(
      <SlotsProvider
        overrides={{
          AgentSessionEventTimeline: ({ segments }) => {
            timelineTitles = segments.map(segment => segment.title);
            return null;
          },
        }}
      >
        <ServerProvider server={createMockAgentUIServer()}>
          <AgentSessionTimelineContainer sessionId="sess-1" events={groupingEvents} />
        </ServerProvider>
      </SlotsProvider>,
    );

    const turn1 = (await screen.findByText('Turn 1')).closest('section');
    const turn2 = screen.getByText('Turn 2').closest('section');
    const turn3 = screen.getByText('Turn 3').closest('section');
    const turn4 = screen.getByText('Turn 4').closest('section');

    expect(turn1).not.toBeNull();
    expect(turn2).not.toBeNull();
    expect(turn3).not.toBeNull();
    expect(turn4).not.toBeNull();
    if (turn1 == null || turn2 == null || turn3 == null || turn4 == null) {
      throw new Error('Expected every backend turn to render a section');
    }
    expect(within(turn1).getByText('turn one response')).toBeInTheDocument();
    expect(within(turn1).queryByText('turn two response')).not.toBeInTheDocument();
    expect(within(turn2).getByText('continue')).toBeInTheDocument();
    expect(within(turn2).getByText('turn two response')).toBeInTheDocument();
    expect(within(turn3).getByText('client-cancelled')).toBeInTheDocument();
    expect(within(turn4).getByText('model failed')).toBeInTheDocument();
    await waitFor(() => {
      expect(timelineTitles).toContain('turn.cancelled');
      expect(timelineTitles).toContain('turn.error');
    });
  });

  it('disables sandbox artifact downloads in session turns', async () => {
    const artifactEvents: SessionEventItem[] = [
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.created',
          id: 'c1',
          turnId: 'turn-1',
          previousTurnId: null,
          input: [{ type: 'user.message', content: 'generate a file' }],
          state: { status: 'running' },
          createdAt: '2026-01-01T00:00:00.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'model.message',
          id: 'm1',
          threadId: 'main',
          content: ['Files ready:', '', '```sandbox_artifacts', '[report.txt](/tmp/report.txt)', '```'].join('\n'),
          createdAt: '2026-01-01T00:00:01.000Z',
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.done',
          id: 'd1',
          state: doneState,
          createdAt: doneState.completedAt,
        },
      },
    ];

    render(
      <SlotsProvider overrides={{ AgentSessionEventTimeline: () => null }}>
        <ServerProvider server={createMockAgentUIServer()}>
          <AgentSessionTimelineContainer sessionId="sess-1" events={artifactEvents} />
        </ServerProvider>
      </SlotsProvider>,
    );

    expect(await screen.findByTestId('aui-sandbox-artifacts')).toBeInTheDocument();
    expect(screen.getByText('report.txt')).toBeInTheDocument();
    expect(screen.queryByLabelText(/Download /)).not.toBeInTheDocument();
    expect(screen.queryAllByRole('link')).toHaveLength(0);

    fireEvent.mouseEnter(screen.getByText('report.txt').parentElement ?? screen.getByText('report.txt'));
    expect(screen.getByRole('tooltip')).toHaveTextContent('Download File is not available in read-only mode');
  });

  it('hides tool approval Allow/Deny actions in session turns', async () => {
    const approvalEvents: SessionEventItem[] = [
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.created',
          id: 'c1',
          turnId: 'turn-1',
          previousTurnId: null,
          input: [{ type: 'user.message', content: 'run tool' }],
          state: { status: 'running' },
          createdAt: '2026-01-01T00:00:00.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'model.message',
          id: 'm1',
          threadId: 'main',
          content: 'calling tool',
          createdAt: '2026-01-01T00:00:01.000Z',
          toolCalls: [
            {
              id: 'approval-1',
              type: 'function',
              function: { name: 'bash', arguments: '{}' },
              toolInfo: {
                type: 'mcp',
                name: 'bash',
                serverId: 'bash-server',
                serverName: 'bash',
              },
            },
          ],
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'tool.approval_required',
          id: 'approval-event',
          threadId: 'main',
          createdAt: '2026-01-01T00:00:01.500Z',
          toolCalls: [{ id: 'approval-1', sourceEventId: 'm1' }],
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.done',
          id: 'd1',
          state: {
            status: 'done',
            completedAt: '2026-01-01T00:00:02.000Z',
            output: null,
            requiredActions: [
              {
                type: 'tool.approval_required',
                id: 'approval-event',
                threadId: 'main',
                createdAt: '2026-01-01T00:00:01.500Z',
                toolCalls: [{ id: 'approval-1', sourceEventId: 'm1' }],
              },
            ],
          },
          createdAt: '2026-01-01T00:00:02.000Z',
          threadId: null,
        },
      },
    ];

    render(
      <SlotsProvider overrides={{ AgentSessionEventTimeline: () => null }}>
        <ServerProvider server={createMockAgentUIServer()}>
          <AgentSessionTimelineContainer sessionId="sess-1" events={approvalEvents} />
        </ServerProvider>
      </SlotsProvider>,
    );

    expect(await screen.findByText('Tool Approval Required for')).toBeInTheDocument();
    expect(screen.queryByRole('button', { name: 'Allow' })).not.toBeInTheDocument();
    expect(screen.queryByRole('button', { name: 'Deny' })).not.toBeInTheDocument();
    expect(screen.queryByRole('button', { name: 'Approve' })).not.toBeInTheDocument();
    expect(screen.queryByText(/Awaiting Response/)).not.toBeInTheDocument();
  });

  it('renders unhandled ask_user_question prompt with Unanswered badge and disabled inputs in replay', async () => {
    const askUserEvents: SessionEventItem[] = [
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.created',
          id: 'c1',
          turnId: 'turn-1',
          previousTurnId: null,
          input: [{ type: 'user.message', content: 'ask me something' }],
          state: { status: 'running' },
          createdAt: '2026-01-01T00:00:00.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'model.message',
          id: 'm1',
          threadId: 'main',
          content: '',
          createdAt: '2026-01-01T00:00:01.000Z',
          toolCalls: [
            {
              id: 'call-ask-1',
              type: 'function',
              function: {
                name: 'ask_user_question',
                arguments: JSON.stringify({
                  question: 'Which environment?',
                  options: ['staging', 'production'],
                }),
              },
            },
          ],
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'tool.response_required',
          id: 'req-ask-1',
          threadId: 'main',
          createdAt: '2026-01-01T00:00:01.500Z',
          toolCalls: [{ id: 'call-ask-1', sourceEventId: 'm1' }],
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.done',
          id: 'd1',
          state: {
            status: 'done',
            completedAt: '2026-01-01T00:00:02.000Z',
            output: null,
            requiredActions: [
              {
                type: 'tool.response_required',
                id: 'req-ask-1',
                threadId: 'main',
                createdAt: '2026-01-01T00:00:01.500Z',
                toolCalls: [{ id: 'call-ask-1', sourceEventId: 'm1' }],
              },
            ],
          },
          createdAt: '2026-01-01T00:00:02.000Z',
          threadId: null,
        },
      },
    ];

    render(
      <SlotsProvider overrides={{ AgentSessionEventTimeline: () => null }}>
        <ServerProvider server={createMockAgentUIServer()}>
          <AgentSessionTimelineContainer sessionId="sess-1" events={askUserEvents} />
        </ServerProvider>
      </SlotsProvider>,
    );

    expect(await screen.findByText('Which environment?')).toBeInTheDocument();
    expect(screen.getByText('Unanswered')).toBeInTheDocument();
    expect(screen.getByRole('radio', { name: 'staging' })).toBeDisabled();
    expect(screen.getByRole('radio', { name: 'production' })).toBeDisabled();
    expect(screen.queryByRole('button', { name: 'Submit' })).not.toBeInTheDocument();
  });

  it('renders MCP Auth Required prompt with disabled Connect button in replay', async () => {
    const mcpAuthEvents: SessionEventItem[] = [
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.created',
          id: 'c1',
          turnId: 'turn-1',
          previousTurnId: null,
          input: [{ type: 'user.message', content: 'fetch external data' }],
          state: { status: 'running' },
          createdAt: '2026-01-01T00:00:00.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.done',
          id: 'd1',
          state: {
            status: 'done',
            completedAt: '2026-01-01T00:00:02.000Z',
            output: null,
            requiredActions: [
              {
                type: 'mcp.auth_required',
                id: 'mcp-req-1',
                threadId: 'main',
                createdAt: '2026-01-01T00:00:01.500Z',
                mcpServers: [
                  {
                    id: 'github-server',
                    name: 'GitHub MCP',
                    authUrl: 'https://auth.github.com',
                  },
                ],
              },
            ],
          },
          createdAt: '2026-01-01T00:00:02.000Z',
          threadId: null,
        },
      },
    ];

    render(
      <SlotsProvider overrides={{ AgentSessionEventTimeline: () => null }}>
        <ServerProvider server={createMockAgentUIServer()}>
          <AgentSessionTimelineContainer sessionId="sess-1" events={mcpAuthEvents} />
        </ServerProvider>
      </SlotsProvider>,
    );

    expect(await screen.findByText('MCP Authentication Required')).toBeInTheDocument();
    expect(screen.getByText('GitHub MCP')).toBeInTheDocument();
    const connectButton = screen.getByRole('button', { name: /Connect/ });
    expect(connectButton).toBeInTheDocument();
    expect(connectButton).toBeDisabled();
  });

  it('renders continuation turn header and input summary for user.mcp_auth_continue', async () => {
    const continueEvents: SessionEventItem[] = [
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.created',
          id: 'c1',
          turnId: 'turn-1',
          previousTurnId: null,
          input: [{ type: 'user.message', content: 'fetch external data' }],
          state: { status: 'running' },
          createdAt: '2026-01-01T00:00:00.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.done',
          id: 'd1',
          state: {
            status: 'done',
            completedAt: '2026-01-01T00:00:02.000Z',
            output: null,
            requiredActions: [
              {
                type: 'mcp.auth_required',
                id: 'mcp-req-1',
                threadId: 'main',
                createdAt: '2026-01-01T00:00:01.500Z',
                mcpServers: [
                  {
                    id: 'github-server',
                    name: 'GitHub MCP',
                    authUrl: 'https://auth.github.com',
                  },
                ],
              },
            ],
          },
          createdAt: '2026-01-01T00:00:02.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-2',
        event: {
          type: 'turn.created',
          id: 'c2',
          turnId: 'turn-2',
          previousTurnId: 'turn-1',
          input: [{ type: 'user.mcp_auth_continue' }],
          state: { status: 'running' },
          createdAt: '2026-01-01T00:00:03.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-2',
        event: {
          type: 'model.message',
          id: 'm2',
          threadId: 'main',
          content: 'resumed after auth',
          createdAt: '2026-01-01T00:00:04.000Z',
        },
      },
      {
        turnId: 'turn-2',
        event: {
          type: 'turn.done',
          id: 'd2',
          state: {
            status: 'done',
            completedAt: '2026-01-01T00:00:05.000Z',
            output: null,
            requiredActions: [],
          },
          createdAt: '2026-01-01T00:00:05.000Z',
          threadId: null,
        },
      },
    ];

    render(
      <SlotsProvider overrides={{ AgentSessionEventTimeline: () => null }}>
        <ServerProvider server={createMockAgentUIServer()}>
          <AgentSessionTimelineContainer sessionId="sess-1" events={continueEvents} />
        </ServerProvider>
      </SlotsProvider>,
    );

    expect(await screen.findByText('Turn 1')).toBeInTheDocument();
    expect(screen.getByText('Turn 2')).toBeInTheDocument();
    expect(screen.getByText('MCP authorization completed')).toBeInTheDocument();
    expect(screen.getByText('resumed after auth')).toBeInTheDocument();
  });

  it('splits empty-input MCP auth resume into Turn 2 with auth widget on Turn 1', async () => {
    const emptyInputResumeEvents: SessionEventItem[] = [
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.created',
          id: 'c1',
          turnId: 'turn-1',
          previousTurnId: null,
          input: [{ type: 'user.message', content: 'Hello' }],
          state: { status: 'running' },
          createdAt: '2026-01-01T00:00:00.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'mcp.auth_required',
          id: 'mcp-req-1',
          threadId: 'main',
          createdAt: '2026-01-01T00:00:01.500Z',
          mcpServers: [
            {
              id: 'linear',
              name: 'linear',
              authUrl: 'https://mcp.linear.app/authorize',
            },
          ],
        },
      },
      {
        turnId: 'turn-1',
        event: {
          type: 'turn.done',
          id: 'd1',
          state: {
            status: 'done',
            completedAt: '2026-01-01T00:00:02.000Z',
            output: null,
            requiredActions: [
              {
                type: 'mcp.auth_required',
                id: 'mcp-req-1',
                threadId: 'main',
                createdAt: '2026-01-01T00:00:01.500Z',
                mcpServers: [
                  {
                    id: 'linear',
                    name: 'linear',
                    authUrl: 'https://mcp.linear.app/authorize',
                  },
                ],
              },
            ],
          },
          createdAt: '2026-01-01T00:00:02.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-2',
        event: {
          type: 'turn.created',
          id: 'c2',
          turnId: 'turn-2',
          previousTurnId: 'turn-1',
          state: { status: 'running' },
          createdAt: '2026-01-01T00:00:03.000Z',
          threadId: null,
        },
      },
      {
        turnId: 'turn-2',
        event: {
          type: 'model.message',
          id: 'm2',
          threadId: 'main',
          content: 'Hello! How can I help you today?',
          createdAt: '2026-01-01T00:00:04.000Z',
        },
      },
      {
        turnId: 'turn-2',
        event: {
          type: 'turn.done',
          id: 'd2',
          state: {
            status: 'done',
            completedAt: '2026-01-01T00:00:05.000Z',
            output: null,
            requiredActions: [],
          },
          createdAt: '2026-01-01T00:00:05.000Z',
          threadId: null,
        },
      },
    ];

    render(
      <SlotsProvider overrides={{ AgentSessionEventTimeline: () => null }}>
        <ServerProvider server={createMockAgentUIServer()}>
          <AgentSessionTimelineContainer sessionId="sess-1" events={emptyInputResumeEvents} />
        </ServerProvider>
      </SlotsProvider>,
    );

    expect(await screen.findByText('Turn 1')).toBeInTheDocument();
    expect(screen.getByText('Turn 2')).toBeInTheDocument();
    expect(screen.getByText('MCP Authentication Required')).toBeInTheDocument();
    expect(screen.getByText('linear')).toBeInTheDocument();
    expect(screen.getByRole('button', { name: /Connect/ })).toBeDisabled();
    expect(screen.getByText('MCP authorization completed')).toBeInTheDocument();
    expect(screen.getByText('Hello! How can I help you today?')).toBeInTheDocument();
  });
});