Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import type { TurnState } from '@service-agent-fold/generated/types';
import { cleanup, render } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { AgentInputProps } from '../ui/AgentInput';
import type { AgentModelSelectorProps } from '../ui/AgentModelSelector';
import type { QueuedPromptsProps } from '../ui/QueuedPrompts';
import { AgentComposer } from './AgentComposer';
const mocks = vi.hoisted(() => ({
session: () => ({ canEdit: false as boolean | undefined }),
turn: () => 'idle' as TurnState,
issue: vi.fn(),
selectModel: vi.fn(),
steer: vi.fn(),
editQueued: vi.fn(),
removeQueued: vi.fn(),
steerQueued: vi.fn(),
upload: vi.fn(),
consumeNotes: vi.fn(),
metadata: () =>
undefined as { model: string; configOptions: { id: string }[] } | undefined,
input: undefined as AgentInputProps | undefined,
model: undefined as AgentModelSelectorProps | undefined,
queued: undefined as QueuedPromptsProps | undefined,
}));
vi.mock('@app/features/changes/context/changes-controller', () => ({
useOptionalChanges: () => ({ consumeSendableNotes: mocks.consumeNotes }),
}));
vi.mock('@channel/Input', () => ({
createInputAttachmentTracker: () => ({
attachments: () => [],
clearAttachments: vi.fn(),
removeAttachment: vi.fn(),
}),
uploadInputAttachments: mocks.upload,
}));
vi.mock('@core/component/Toast/Toast', () => ({ toast: { failure: vi.fn() } }));
vi.mock('@core/util/upload', () => ({ uploadFile: vi.fn() }));
vi.mock('../context/AgentSessionContext', () => ({
useAgentSession: () => ({
session: () => mocks.session(),
displayName: (id: string) => id,
userId: () => 'viewer',
interactions: { pending: () => [], canAnswer: () => false },
toolApprovals: { pending: () => [] },
issue: mocks.issue,
selectModel: mocks.selectModel,
loadFailed: () => false,
messages: () => [],
metadata: () => mocks.metadata(),
pending: () => false,
initialInput: 'Document context',
queue: {
entries: () => [
{ actionId: 'queued-1', kind: 'prompt', prompt: 'Queued request' },
],
edit: mocks.editQueued,
remove: mocks.removeQueued,
steer: mocks.steerQueued,
},
steer: mocks.steer,
steerFailed: () => new Set(),
turn: () => mocks.turn(),
sessionId: () => 'session-1',
registerQuoteInsert: vi.fn(),
}),
}));
vi.mock('../ui', () => ({
AgentInput: (props: AgentInputProps) => {
mocks.input = props;
return <div>{props.modelControl}</div>;
},
AgentModelSelector: (props: AgentModelSelectorProps) => {
mocks.model = props;
return null;
},
QueuedPrompts: (props: QueuedPromptsProps) => {
mocks.queued = props;
return null;
},
ComposerNotice: () => null,
}));
vi.mock('./PermissionRequest', () => ({ PermissionRequest: () => null }));
beforeEach(() => {
localStorage.clear();
vi.resetAllMocks();
mocks.turn = () => 'idle';
mocks.metadata = () => undefined;
mocks.session = () => ({ canEdit: false });
mocks.issue.mockResolvedValue({ isErr: () => false });
});
afterEach(cleanup);
it('passes opening context to the composer without issuing it', () => {
render(() => <AgentComposer />);
expect(mocks.input?.initialInput).toBe('Document context');
expect(mocks.issue).not.toHaveBeenCalled();
});
describe('view-only session controls', () => {
it('disables and guards prompt, model, stop, queue, and attachment actions', () => {
render(() => <AgentComposer />);
expect(mocks.input?.disabled).toBe(true);
expect(mocks.input?.readOnly).toBe(true);
expect(mocks.input?.placeholder).toBe(
'You have view-only access to this agent session'
);
expect(mocks.model?.disabled).toBe(true);
expect(mocks.queued?.disabled).toBe(true);
mocks.input?.onSend('A new prompt', []);
mocks.input?.onStop?.();
mocks.input?.onAttachFiles?.([new File(['text'], 'note.txt')]);
mocks.model?.onSelect('new-model');
mocks.queued?.onEdit('queued-1', 'Edited prompt');
mocks.queued?.onRemove('queued-1');
expect(mocks.issue).not.toHaveBeenCalled();
expect(mocks.selectModel).not.toHaveBeenCalled();
expect(mocks.upload).not.toHaveBeenCalled();
expect(mocks.consumeNotes).not.toHaveBeenCalled();
mocks.queued?.onSteer?.('queued-1');
expect(mocks.editQueued).not.toHaveBeenCalled();
expect(mocks.removeQueued).not.toHaveBeenCalled();
expect(mocks.steer).not.toHaveBeenCalled();
expect(mocks.queued?.onSteer).toBeUndefined();
});
it('steers one queued message while a turn is in flight', () => {
mocks.session = () => ({ canEdit: true });
mocks.turn = () => 'running';
render(() => <AgentComposer />);
expect(mocks.queued?.onSteer).toEqual(expect.any(Function));
mocks.queued?.onSteer?.('queued-1');
expect(mocks.steer).toHaveBeenCalledWith('queued-1');
});
it('reacts to a permission downgrade without remounting', () => {
const [canEdit, setCanEdit] = createSignal(true);
mocks.session = () => ({ canEdit: canEdit() });
render(() => <AgentComposer />);
expect(mocks.input?.disabled).toBe(false);
expect(mocks.model?.disabled).toBe(false);
setCanEdit(false);
expect(mocks.input?.readOnly).toBe(true);
expect(mocks.model?.disabled).toBe(true);
expect(mocks.queued?.disabled).toBe(true);
mocks.input?.onSend('Cannot send now', []);
expect(mocks.issue).not.toHaveBeenCalled();
expect(mocks.selectModel).not.toHaveBeenCalled();
});
it.each([true, undefined])(
'preserves editable drafts before a read-only result (%s)',
(canEdit) => {
mocks.session = () => ({ canEdit });
render(() => <AgentComposer />);
expect(mocks.input?.disabled).toBe(false);
expect(mocks.input?.readOnly).toBe(false);
expect(mocks.queued?.disabled).toBe(false);
mocks.input?.onSend('A permitted prompt', []);
expect(mocks.issue).toHaveBeenCalledWith({
type: 'prompt',
prompt: 'A permitted prompt',
});
}
);
});
it('keeps steering queued messages while the turn transitions', () => {
const [turn, setTurn] = createSignal<TurnState>('running');
mocks.turn = turn;
mocks.session = () => ({ canEdit: true });
render(() => <AgentComposer />);
expect(mocks.queued?.onSteer).toEqual(expect.any(Function));
for (const next of ['stopping', 'starting'] as const) {
setTurn(next);
expect(mocks.queued?.onSteer).toEqual(expect.any(Function));
}
});
it('retains an unsent draft when speed configuration is rejected', async () => {
mocks.session = () => ({ canEdit: true });
mocks.metadata = () => ({
model: 'openai/gpt-6-astra',
configOptions: [{ id: 'speed' }],
});
mocks.selectModel.mockRejectedValue(new Error('Unavailable'));
render(() => <AgentComposer />);
mocks.input?.onDraftChange?.('Keep this draft');
mocks.input?.onDraftChange?.('');
mocks.input?.onSend('Keep this draft', []);
await vi.waitFor(() => expect(mocks.input?.draft).toBe('Keep this draft'));
expect(mocks.issue).not.toHaveBeenCalled();
expect(mocks.consumeNotes).not.toHaveBeenCalled();
});
it('leaves external agent speed settings alone', () => {
mocks.session = () => ({ canEdit: true });
mocks.metadata = () => ({
model: 'external/model',
configOptions: [{ id: 'speed' }],
});
render(() => <AgentComposer />);
mocks.input?.onSend('Use external settings', []);
expect(mocks.selectModel).not.toHaveBeenCalled();
expect(mocks.issue).toHaveBeenCalledWith({
type: 'prompt',
prompt: 'Use external settings',
});
});
it('retains the draft if editing access is revoked while applying speed', async () => {
const [canEdit, setCanEdit] = createSignal(true);
mocks.session = () => ({ canEdit: canEdit() });
mocks.metadata = () => ({
model: 'openai/gpt-6-astra',
configOptions: [{ id: 'speed' }],
});
let finish!: () => void;
mocks.selectModel.mockImplementation(
() =>
new Promise<void>((resolve) => {
finish = resolve;
})
);
render(() => <AgentComposer />);
mocks.input?.onSend('Keep after permission change', []);
setCanEdit(false);
finish();
await vi.waitFor(() =>
expect(mocks.input?.draft).toBe('Keep after permission change')
);
expect(mocks.issue).not.toHaveBeenCalled();
expect(mocks.consumeNotes).not.toHaveBeenCalled();
});
it('allows another prompt after a failed turn', () => {
mocks.session = () => ({ canEdit: true });
mocks.turn = () => 'failed';
render(() => <AgentComposer />);
expect(mocks.input?.busy).toBe(false);
mocks.input?.onSend('Try again', []);
expect(mocks.issue).toHaveBeenCalledWith({
type: 'prompt',
prompt: 'Try again',
});
});