The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
import { describe, expect, it } from 'vitest';
import type { ThreadMessage } from '../../types/thread';
import {
coerceWorkflowProposal,
extractWorkflowProposalFromMessages,
maybeParseWorkflowProposalTool,
parseWorkflowProposal,
} from './workflowProposal';
const proposalPayload = (name: string) => ({
type: 'workflow_proposal',
persisted: false,
name,
graph: { nodes: [], edges: [] },
require_approval: true,
summary: {
trigger: 'schedule: 0 9 * * *',
steps: [{ kind: 'tool_call', name: 'Fetch trending tweets', config_hint: 'TWITTER_SEARCH' }],
},
});
const message = (
id: string,
extraMetadata: Record<string, unknown>,
overrides: Partial<ThreadMessage> = {}
): ThreadMessage => ({
id,
content: 'Workflow proposal ready',
type: 'text',
extraMetadata,
sender: 'agent',
createdAt: '2026-07-21T06:00:00Z',
...overrides,
});
describe('parseWorkflowProposal / coerceWorkflowProposal', () => {
it('parses a valid proposal payload with summary steps', () => {
const proposal = parseWorkflowProposal(JSON.stringify(proposalPayload('Daily X Trending')));
expect(proposal).not.toBeNull();
expect(proposal?.name).toBe('Daily X Trending');
expect(proposal?.requireApproval).toBe(true);
expect(proposal?.summary.trigger).toBe('schedule: 0 9 * * *');
expect(proposal?.summary.steps).toEqual([
{ kind: 'tool_call', name: 'Fetch trending tweets', config_hint: 'TWITTER_SEARCH' },
]);
});
it('defaults requireApproval to true unless explicitly false', () => {
const explicit = coerceWorkflowProposal({ ...proposalPayload('X'), require_approval: false });
expect(explicit?.requireApproval).toBe(false);
const omitted = coerceWorkflowProposal({ type: 'workflow_proposal', name: 'X', graph: {} });
expect(omitted?.requireApproval).toBe(true);
});
it('normalizes invalid summary steps without rejecting the proposal', () => {
const proposal = coerceWorkflowProposal({
...proposalPayload('Mixed steps'),
summary: {
trigger: 42,
steps: [
null,
'not an object',
{ kind: 7, name: false, config_hint: ['not', 'a', 'string'] },
],
},
});
expect(proposal?.summary).toEqual({
trigger: '',
steps: [{ kind: 'unknown', name: '', config_hint: undefined }],
});
});
it('rejects non-proposal payloads, malformed JSON, and missing fields', () => {
expect(parseWorkflowProposal('not json')).toBeNull();
expect(coerceWorkflowProposal(null)).toBeNull();
expect(coerceWorkflowProposal({ type: 'something_else' })).toBeNull();
expect(coerceWorkflowProposal({ type: 'workflow_proposal', graph: {} })).toBeNull();
expect(coerceWorkflowProposal({ type: 'workflow_proposal', name: 'x' })).toBeNull();
});
});
describe('maybeParseWorkflowProposalTool', () => {
it('is content-based: any tool name with a proposal-shaped output matches', () => {
const output = JSON.stringify(proposalPayload('Via Edit Tool'));
expect(maybeParseWorkflowProposalTool('edit_workflow', true, output)?.name).toBe(
'Via Edit Tool'
);
expect(maybeParseWorkflowProposalTool('totally_new_tool', true, output)?.name).toBe(
'Via Edit Tool'
);
});
it('ignores failed calls and empty output', () => {
const output = JSON.stringify(proposalPayload('X'));
expect(maybeParseWorkflowProposalTool('propose_workflow', false, output)).toBeNull();
expect(maybeParseWorkflowProposalTool('propose_workflow', true, undefined)).toBeNull();
});
});
describe('coerceWorkflowProposal flow_id', () => {
it('keeps the flow a revision targets and omits it for a new proposal', () => {
const revision = parseWorkflowProposal(
JSON.stringify({ ...proposalPayload('Revised'), flow_id: 'flow-1', draft_id: 'draft-1' })
);
expect(revision?.flowId).toBe('flow-1');
expect(parseWorkflowProposal(JSON.stringify(proposalPayload('New')))).not.toHaveProperty(
'flowId'
);
});
});
describe('extractWorkflowProposalFromMessages', () => {
it('rehydrates the newest unconsumed proposal and tags its source message', () => {
const messages = [
message('m1', { scope: 'workflow_proposal', proposal: proposalPayload('Old Draft') }),
message('m2', {}),
message('m3', { scope: 'workflow_proposal', proposal: proposalPayload('Latest Draft') }),
];
const proposal = extractWorkflowProposalFromMessages(messages);
expect(proposal?.name).toBe('Latest Draft');
expect(proposal?.sourceMessageId).toBe('m3');
});
it('returns nothing once the newest proposal is consumed: older revisions are superseded', () => {
const messages = [
message('m1', { scope: 'workflow_proposal', proposal: proposalPayload('Superseded') }),
message('m2', {
scope: 'workflow_proposal',
proposal: proposalPayload('Already Saved'),
consumed: true,
}),
];
expect(extractWorkflowProposalFromMessages(messages)).toBeNull();
});
it('carries the saved flow id so a reloaded card resumes at the enable step', () => {
const messages = [
message('m1', {
scope: 'workflow_proposal',
proposal: proposalPayload('Saved Not Enabled'),
saved_flow_id: 'flow-7',
}),
];
expect(extractWorkflowProposalFromMessages(messages)?.savedFlowId).toBe('flow-7');
});
it('returns null when there is no proposal metadata or the payload is malformed', () => {
expect(extractWorkflowProposalFromMessages([])).toBeNull();
expect(extractWorkflowProposalFromMessages([message('m1', {})])).toBeNull();
expect(
extractWorkflowProposalFromMessages([
message('m1', { scope: 'workflow_proposal', proposal: { type: 'wrong' } }),
])
).toBeNull();
});
});