The open-source agent harness - the runtime layer that turns an LLM into a working agent.
// @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' })),
);
});
});