Skip to content

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

25.3 KB
Raw Blame
// @vitest-environment jsdom
import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
import { cloneElement, isValidElement, useEffect, useLayoutEffect, type ReactNode } from 'react';
import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';

import { SaveAgentButton } from '@/atoms/SaveAgentButton.js';
import {
  AgentConfigInstructionsProvider,
  useAgentConfigInstructions,
} from '@/atoms/draft/AgentConfigInstructionsContext.js';
import { ServerProvider } from '@/server/ServerContext.js';
import { ShellModeProvider, useShellMode, type AgentConfig } from '@/server/ShellModeContext.js';
import type {
  AgentSpec,
  AgentUIServer,
  ListPermissionsResponse,
  SaveAgentRequest,
  SaveAgentResult,
} from '@/server/types.js';
import { SlotsProvider } from '@/theme/SlotsProvider.js';
import { createMockAgentUIServer } from '../server/mockServer.js';

let agentSpec: AgentSpec;
const flushAgentSpec = vi.fn(async () => undefined);
const adoptAgentSpec = vi.fn();
const updateAgentSpec = vi.fn();

vi.mock('@truefoundry/trueforge-assistant-ui-runtime', () => ({
  useTrueForgeAgentSpec: () => ({ agentSpec, draftSessionId: 'draft-1' }),
  useTrueForgeFlushAgentSpec: () => flushAgentSpec,
  useTrueForgeAdoptAgentSpec: () => adoptAgentSpec,
  useTrueForgeUpdateAgentSpec: () => updateAgentSpec,
}));

beforeAll(() => {
  HTMLDialogElement.prototype.showModal = function showModal() {
    this.setAttribute('open', '');
  };
  HTMLDialogElement.prototype.close = function close() {
    this.removeAttribute('open');
    this.dispatchEvent(new Event('close'));
  };
});

function OpenAgentBuilderOnMount({ children }: { children: ReactNode }) {
  const { openAgentBuilder, mode } = useShellMode();
  useLayoutEffect(() => {
    if (mode.status === 'active' && mode.isMutable && !mode.isCreateAgent) {
      openAgentBuilder();
    }
  }, [mode, openAgentBuilder]);
  return children;
}

function renderButton({
  saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'agent-1' })),
  agentConfig = { mode: 'AgentComposer' as const },
  serverOverrides = {},
  children = <SaveAgentButton />,
}: {
  saveAgent?: (request: SaveAgentRequest) => Promise<SaveAgentResult>;
  agentConfig?: AgentConfig;
  serverOverrides?: Partial<AgentUIServer>;
  children?: ReactNode;
} = {}) {
  const server = createMockAgentUIServer({
    getModels: async () => [
      {
        id: 'openai/gpt-4.1',
        name: 'openai/gpt-4.1',
        provider: { name: 'OpenAI' },
        properties: {},
      },
      {
        id: 'anthropic/claude-sonnet-4-6',
        name: 'anthropic/claude-sonnet-4-6',
        provider: { name: 'Anthropic' },
        properties: {},
      },
    ],
    getMcp: async () => [
      { id: 'github', name: 'GitHub', authenticated: true },
      { id: 'slack', name: 'Slack', authenticated: true },
    ],
    getSkills: async () => [
      { id: 'research', name: 'Research' },
      { id: 'writing', name: 'Writing' },
    ],
    ...serverOverrides,
    saveAgent,
  });
  const tree = () => (
    <SlotsProvider>
      <ServerProvider server={server}>
        <ShellModeProvider agentConfig={agentConfig}>
          <OpenAgentBuilderOnMount>
            {isValidElement(children) ? cloneElement(children) : children}
          </OpenAgentBuilderOnMount>
        </ShellModeProvider>
      </ServerProvider>
    </SlotsProvider>
  );
  const rendered = render(tree());
  return {
    saveAgent,
    ...rendered,
    rerenderButton: () => rendered.rerender(tree()),
  };
}

function BoundMutableSaveButton({
  agentId,
  agentName,
  description,
}: {
  agentId: string;
  agentName?: string;
  description?: string;
}) {
  const { selectLibraryAgent } = useShellMode();
  useEffect(() => {
    selectLibraryAgent({
      isMutable: true,
      isCreateAgent: true,
      agentId,
      agentName,
      description,
      agentSpec,
    });
  }, [agentId, agentName, description, selectLibraryAgent]);
  return <SaveAgentButton />;
}

function CloneDraftSaveButton({ agentName, description }: { agentName: string; description?: string }) {
  const { selectLibraryAgent } = useShellMode();
  useEffect(() => {
    selectLibraryAgent({
      isMutable: true,
      isCreateAgent: true,
      agentName,
      ...(description === undefined ? {} : { description }),
      agentSpec,
    });
  }, [agentName, description, selectLibraryAgent]);
  return <SaveAgentButton />;
}

function SaveWithInstructionDraft() {
  const { onChange } = useAgentConfigInstructions();
  return (
    <>
      <button type="button" onClick={() => onChange('Instructions currently visible in the drawer.')}>
        Edit instructions
      </button>
      <SaveAgentButton />
    </>
  );
}

function deferred<T>() {
  let resolvePromise: ((value: T) => void) | undefined;
  const promise = new Promise<T>(resolve => {
    resolvePromise = resolve;
  });
  return {
    promise,
    resolve(value: T) {
      if (resolvePromise === undefined) throw new Error('Deferred promise was not initialized');
      resolvePromise(value);
    },
  };
}

describe('SaveAgentButton', () => {
  beforeEach(() => {
    agentSpec = {
      model: { name: 'openai/gpt-4.1' },
      instructions: 'Be helpful.',
      mcpServers: [{ id: 'github', name: 'GitHub' }],
      skills: [{ id: 'research', name: 'Research' }],
    };
    flushAgentSpec.mockReset();
    flushAgentSpec.mockResolvedValue(undefined);
    adoptAgentSpec.mockClear();
    updateAgentSpec.mockClear();
  });

  it('is hidden when the shell is locked to a named agent', () => {
    renderButton({ agentConfig: { mode: 'SingleAgent', name: 'locked-agent' } });
    expect(screen.queryByRole('button', { name: 'Save Agent' })).not.toBeInTheDocument();
  });

  it('shows on an empty new chat when a model is selected', () => {
    renderButton();
    expect(screen.getByRole('button', { name: 'Save Agent' })).toHaveClass(
      'bg-primary-button-bg',
      'text-primary-button-text',
    );
  });

  it('is hidden when the draft has no model', () => {
    agentSpec = {
      model: { name: '' },
      skills: [{ id: 's1', name: 'Skill One' }],
    };
    renderButton();
    expect(screen.queryByRole('button', { name: 'Save Agent' })).not.toBeInTheDocument();
  });

  it('is hidden in idle library mode without loading catalogs', () => {
    const getModels = vi.fn(async () => []);
    const getSkills = vi.fn(async () => []);
    const getMcp = vi.fn(async () => []);
    renderButton({
      agentConfig: { mode: 'AgentLibrary' },
      serverOverrides: { getModels, getSkills, getMcp },
    });

    expect(screen.queryByRole('button', { name: 'Save Agent' })).not.toBeInTheDocument();
    expect(getModels).not.toHaveBeenCalled();
    expect(getSkills).not.toHaveBeenCalled();
    expect(getMcp).not.toHaveBeenCalled();
  });

  it('uses SDK theme tokens for editable controls', async () => {
    renderButton();
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));

    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    expect(dialog).toHaveClass('bg-card-bg', 'text-text-primary', 'md:ml-auto', 'md:mr-0', 'md:h-dvh');
    expect(within(dialog).getByLabelText('Agent name')).toHaveClass(
      'border-input-border',
      'bg-input-box-bg',
      'text-text-primary',
      'focus-visible:ring-focus-ring/40',
    );
    expect(within(dialog).getByLabelText('Description')).toBeInTheDocument();
    expect(within(dialog).queryByRole('button', { name: 'Edit Model' })).not.toBeInTheDocument();
    expect(within(dialog).queryByRole('button', { name: 'Edit Runtime Config' })).not.toBeInTheDocument();
    expect(within(dialog).queryByRole('button', { name: 'Edit Connectors' })).not.toBeInTheDocument();
    expect(within(dialog).queryByRole('button', { name: 'Edit Skills' })).not.toBeInTheDocument();
  });

  it('preserves configuration without exposing unsupported fields', async () => {
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'agent-1' }));
    renderButton({ saveAgent });
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));

    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'writer' } });
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: 'Writes docs.' } });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    await waitFor(() =>
      expect(saveAgent).toHaveBeenCalledWith(
        expect.objectContaining({
          agentSpec: expect.objectContaining({
            instructions: 'Be helpful.',
            mcpServers: [{ id: 'github', name: 'GitHub' }],
            skills: [{ id: 'research', name: 'Research' }],
          }),
        }),
      ),
    );
  });

  it('opens with the latest runtime spec after flushing pending picker edits', async () => {
    const pendingFlush = deferred<undefined>();
    flushAgentSpec.mockReturnValueOnce(pendingFlush.promise);
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'agent-1' }));
    const rendered = renderButton({ saveAgent });

    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    await waitFor(() => expect(flushAgentSpec).toHaveBeenCalledOnce());

    agentSpec = {
      model: { name: 'openai/gpt-4.1' },
      instructions: 'Latest flushed instructions.',
      mcpServers: [{ id: 'slack', name: 'Slack' }],
      skills: [{ id: 'writing', name: 'Writing' }],
      config: { generativeUi: { enabled: false } },
    };
    rendered.rerenderButton();
    pendingFlush.resolve(undefined);

    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'latest-agent' } });
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: 'Latest agent description.' } });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    await waitFor(() =>
      expect(saveAgent).toHaveBeenCalledWith(
        expect.objectContaining({
          agentSpec: expect.objectContaining({
            instructions: 'Latest flushed instructions.',
            mcpServers: [{ id: 'slack', name: 'Slack' }],
            skills: [{ id: 'writing', name: 'Writing' }],
            config: { generativeUi: { enabled: false } },
          }),
        }),
      ),
    );
  });

  it('uses the drawer instruction draft when opening before debounce sync completes', async () => {
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'agent-1' }));
    renderButton({
      saveAgent,
      children: <SaveAgentButton instructionsOverride="Instructions currently visible in the drawer." />,
    });

    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'writer' } });
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: 'Writes docs.' } });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    await waitFor(() =>
      expect(saveAgent).toHaveBeenCalledWith(
        expect.objectContaining({
          agentSpec: expect.objectContaining({ instructions: 'Instructions currently visible in the drawer.' }),
        }),
      ),
    );
  });

  it('flushes the shared instruction draft when opening Save Agent', async () => {
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'agent-1' }));
    renderButton({
      saveAgent,
      children: (
        <AgentConfigInstructionsProvider>
          <SaveWithInstructionDraft />
        </AgentConfigInstructionsProvider>
      ),
    });

    fireEvent.click(screen.getByRole('button', { name: 'Edit instructions' }));
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'writer' } });
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: 'Writes docs.' } });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    expect(updateAgentSpec).toHaveBeenCalledWith({
      instructions: 'Instructions currently visible in the drawer.',
    });
    await waitFor(() =>
      expect(saveAgent).toHaveBeenCalledWith(
        expect.objectContaining({
          agentSpec: expect.objectContaining({ instructions: 'Instructions currently visible in the drawer.' }),
        }),
      ),
    );
  });

  it('labels an existing mutable binding as Update Agent and submits an update', async () => {
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'writer' }));
    renderButton({
      saveAgent,
      children: <BoundMutableSaveButton agentId="writer" description="Writes docs." />,
    });

    const trigger = await screen.findByRole('button', { name: 'Update Agent' });
    expect(screen.queryByRole('button', { name: 'Save Agent' })).not.toBeInTheDocument();
    fireEvent.click(trigger);
    const dialog = await screen.findByRole('dialog', { name: 'Update agent' });
    expect(within(dialog).getByLabelText('Agent name')).toHaveValue('writer');
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    await waitFor(() =>
      expect(saveAgent).toHaveBeenCalledWith(expect.objectContaining({ agentName: 'writer', intent: 'update' })),
    );
  });

  it('treats a named create draft (clone) as Save Agent create, not update', async () => {
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'writer-clone-id' }));
    renderButton({
      saveAgent,
      children: <CloneDraftSaveButton agentName="writer-clone" description="Writes docs." />,
    });

    const trigger = await screen.findByRole('button', { name: 'Save Agent' });
    expect(screen.queryByRole('button', { name: 'Update Agent' })).not.toBeInTheDocument();
    fireEvent.click(trigger);
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    expect(within(dialog).getByLabelText('Agent name')).toHaveValue('writer-clone');
    expect(within(dialog).getByLabelText('Description')).toHaveValue('Writes docs.');
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    await waitFor(() =>
      expect(saveAgent).toHaveBeenCalledWith(expect.objectContaining({ agentName: 'writer-clone', intent: 'create' })),
    );
  });

  it('discards drawer-only changes when closed', async () => {
    renderButton();
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'discard-me' } });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Close' }));

    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const reopened = await screen.findByRole('dialog', { name: 'Save agent' });
    expect(within(reopened).getByLabelText('Agent name')).toHaveValue('');
  });

  it('submits one explicit create request and adopts the persisted session spec', async () => {
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({
      agentId: 'agent-1',
      sessionUpdatedAt: '2026-08-12T08:00:00.000Z',
    }));
    renderButton({ saveAgent });
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'my-agent' } });
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: 'My agent description.' } });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    await waitFor(() => expect(saveAgent).toHaveBeenCalledOnce());
    expect(saveAgent).toHaveBeenCalledWith({
      agentName: 'my-agent',
      description: 'My agent description.',
      agentSpec: {
        model: { name: 'openai/gpt-4.1', params: undefined },
        instructions: 'Be helpful.',
        mcpServers: [{ id: 'github', name: 'GitHub' }],
        skills: [{ id: 'research', name: 'Research' }],
        config: undefined,
      },
      intent: 'create',
      sessionId: 'draft-1',
    });
    await waitFor(() =>
      expect(adoptAgentSpec).toHaveBeenCalledWith({
        agentSpec: expect.objectContaining({ model: { name: 'openai/gpt-4.1', params: undefined } }),
        updatedAt: '2026-08-12T08:00:00.000Z',
      }),
    );
    expect(screen.getByRole('button', { name: 'Update Agent' })).toBeInTheDocument();
    expect(screen.queryByRole('button', { name: 'Save Agent' })).not.toBeInTheDocument();
  });

  it('preserves opaque mount fields without exposing resource editors', async () => {
    agentSpec = {
      model: { name: 'openai/gpt-4.1' },
      mcpServers: [{ id: 'github', name: 'GitHub', enableTools: ['@read-only'], config: { project: 'sdk' } }],
      skills: [{ id: 'research', name: 'Research', fqn: 'skills/research:1', config: { depth: 2 } }],
    };
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'agent-1' }));
    renderButton({ saveAgent });
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const saveDialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(saveDialog).getByLabelText('Agent name'), { target: { value: 'preserved-agent' } });
    fireEvent.change(within(saveDialog).getByLabelText('Description'), {
      target: { value: 'Preserved agent description.' },
    });
    fireEvent.click(within(saveDialog).getByRole('button', { name: 'Save changes' }));

    await waitFor(() => expect(saveAgent).toHaveBeenCalledOnce());
    expect(saveAgent).toHaveBeenCalledWith(
      expect.objectContaining({
        agentSpec: expect.objectContaining({
          mcpServers: [{ id: 'github', name: 'GitHub', enableTools: ['@read-only'], config: { project: 'sdk' } }],
          skills: [{ id: 'research', name: 'Research', fqn: 'skills/research:1', config: { depth: 2 } }],
        }),
      }),
    );
  });

  it('keeps the save form immutable until an in-flight request settles', async () => {
    const pending = deferred<SaveAgentResult>();
    renderButton({ saveAgent: vi.fn(() => pending.promise) });
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'pending-agent' } });
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: 'Pending agent description.' } });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    expect(within(dialog).getByLabelText('Agent name')).toBeDisabled();
    expect(within(dialog).getByRole('button', { name: 'Cancel' })).toBeDisabled();

    pending.resolve({ agentId: 'agent-1' });
    await waitFor(() => expect(screen.queryByRole('dialog', { name: 'Save agent' })).not.toBeInTheDocument());
  });

  it('surfaces API-shaped save errors', async () => {
    renderButton({
      saveAgent: vi.fn(async () => {
        throw { body: { error: { message: 'Agent name already exists' } } };
      }),
    });
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'duplicate' } });
    fireEvent.change(within(dialog).getByLabelText('Description'), {
      target: { value: 'Duplicate agent description.' },
    });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    expect(await within(dialog).findByRole('alert')).toHaveTextContent('Agent name already exists');
  });

  it('preserves decoded escapes in validation error messages', async () => {
    renderButton({
      saveAgent: vi.fn(async () => {
        throw {
          body: {
            error: {
              message: 'line one\\nline two\\tindented',
            },
          },
        };
      }),
    });
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'bad name' } });
    fireEvent.change(within(dialog).getByLabelText('Description'), {
      target: { value: 'Bad name agent description.' },
    });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));

    const alert = await within(dialog).findByRole('alert');
    expect(alert).toHaveClass('whitespace-pre-wrap');
    expect(alert.textContent).toBe('line one\nline two\tindented');
  });

  it('disables Save on create when description is empty', async () => {
    renderButton();
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Save agent' });
    fireEvent.change(within(dialog).getByLabelText('Agent name'), { target: { value: 'writer' } });
    expect(within(dialog).getByRole('button', { name: 'Save changes' })).toBeDisabled();
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: 'Writes docs.' } });
    expect(within(dialog).getByRole('button', { name: 'Save changes' })).toBeEnabled();
  });

  it('disables Save on update when description is empty', async () => {
    renderButton({
      children: <BoundMutableSaveButton agentId="writer" agentName="writer" description="Existing agent summary." />,
    });
    fireEvent.click(await screen.findByRole('button', { name: 'Update Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Update agent' });
    expect(within(dialog).getByRole('button', { name: 'Save changes' })).toBeEnabled();
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: '   ' } });
    expect(within(dialog).getByRole('button', { name: 'Save changes' })).toBeDisabled();
    fireEvent.change(within(dialog).getByLabelText('Description'), { target: { value: 'Updated summary.' } });
    expect(within(dialog).getByRole('button', { name: 'Save changes' })).toBeEnabled();
  });

  it('prefills description on update intent', async () => {
    agentSpec = {
      model: { name: 'openai/gpt-4.1' },
      instructions: 'Be helpful.',
    };
    renderButton({
      children: <BoundMutableSaveButton agentId="writer" agentName="writer" description="Existing agent summary." />,
    });
    fireEvent.click(await screen.findByRole('button', { name: 'Update Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Update agent' });
    expect(within(dialog).getByLabelText('Agent name')).toHaveValue('writer');
    expect(within(dialog).getByLabelText('Description')).toHaveValue('Existing agent summary.');
  });

  it('enables Save Agent when tenant CREATE is granted', async () => {
    renderButton({
      serverOverrides: {
        permissions: {
          listPermissions: vi.fn(async (): Promise<ListPermissionsResponse> => ({
            data: { type: 'tenant', permissions: { agent: ['CREATE'] } },
          })),
        },
      },
    });
    await waitFor(() => expect(screen.getByRole('button', { name: 'Save Agent' })).toBeEnabled());
    fireEvent.click(screen.getByRole('button', { name: 'Save Agent' }));
    expect(await screen.findByRole('dialog', { name: 'Save agent' })).toBeInTheDocument();
  });

  it('disables Save Agent without tenant CREATE and shows a permission tooltip', async () => {
    renderButton({
      serverOverrides: {
        permissions: {
          listPermissions: vi.fn(async (): Promise<ListPermissionsResponse> => ({
            data: { type: 'tenant', permissions: { agent: [] } },
          })),
        },
      },
    });
    await waitFor(() => expect(screen.getByRole('button', { name: 'Save Agent' })).toBeDisabled());
    const trigger = screen.getByRole('button', { name: 'Save Agent' });
    fireEvent.mouseEnter(trigger.parentElement ?? trigger);
    expect(screen.getByRole('tooltip')).toHaveTextContent('No permission to create agents');
  });

  it('keeps Update Agent enabled for MANAGE without tenant CREATE', async () => {
    const saveAgent = vi.fn(async (): Promise<SaveAgentResult> => ({ agentId: 'writer' }));
    renderButton({
      saveAgent,
      children: <BoundMutableSaveButton agentId="writer" agentName="writer" description="Writes docs." />,
      serverOverrides: {
        permissions: {
          listPermissions: vi.fn(async ({ resourceType }): Promise<ListPermissionsResponse> =>
            resourceType === 'tenant'
              ? { data: { type: 'tenant', permissions: { agent: [] } } }
              : { data: { type: 'agent', permissions: { writer: ['MANAGE'] } } },
          ),
        },
      },
    });
    await waitFor(() => expect(screen.getByRole('button', { name: 'Update Agent' })).toBeEnabled());
    fireEvent.click(screen.getByRole('button', { name: 'Update Agent' }));
    const dialog = await screen.findByRole('dialog', { name: 'Update agent' });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save changes' }));
    await waitFor(() =>
      expect(saveAgent).toHaveBeenCalledWith(expect.objectContaining({ agentName: 'writer', intent: 'update' })),
    );
  });
});