Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
import { describe, expect, it } from 'vitest';
import {
WORKFLOW_CONTROL_REQUEST_TIMEOUT,
assertWorkflowControlMutationSucceeded,
extractWorkflowControlStatusSnapshot,
isWorkflowControlMutationConfirmed,
isWorkflowResetRecoveryConfirmed,
mergeWorkflowControlStatus,
normalizeWorkflowControlStatus,
shouldRetryResetWorkflowAfterConflict,
type WorkflowControlMutationAction,
type WorkflowControlState,
type WorkflowControlStatus,
type WorkflowStartResult,
} from '../WebSocketContext';
const status = (
overrides: Partial<WorkflowControlStatus> = {},
): WorkflowControlStatus => ({
workflow_id: 'workflow-1',
generation: 1,
state: 'running',
revision: 1,
active_count: 0,
in_flight_count: 0,
queued_count: 0,
can_start: false,
can_pause: true,
can_resume: false,
can_reset: true,
can_edit: false,
...overrides,
});
describe('workflow control status ordering', () => {
it('rejects an older generation even when it carries a larger revision', () => {
const current = status({ generation: 3, revision: 2, state: 'running' });
const stale = status({ generation: 2, revision: 99, state: 'paused' });
expect(mergeWorkflowControlStatus(current, stale)).toBe(current);
});
it('accepts a newer pre-migration generation whose revision restarted', () => {
const current = status({ generation: 2, revision: 8, state: 'ready' });
const incoming = status({ generation: 3, revision: 1, state: 'starting' });
expect(mergeWorkflowControlStatus(current, incoming)).toBe(incoming);
});
it('rejects a lower revision in the same generation', () => {
const current = status({ generation: 4, revision: 7, state: 'paused' });
const stale = status({ generation: 4, revision: 6, state: 'running' });
expect(mergeWorkflowControlStatus(current, stale)).toBe(current);
});
it('accepts equal-version runtime count refreshes', () => {
const current = status({ generation: 4, revision: 7, active_count: 1 });
const incoming = status({ generation: 4, revision: 7, active_count: 2 });
expect(mergeWorkflowControlStatus(current, incoming)).toBe(incoming);
});
it('normalizes nested snapshots and numeric version strings', () => {
const normalized = normalizeWorkflowControlStatus({
status: {
workflow_id: 'workflow-1',
generation: '5',
revision: '11',
workspace_epoch: '3',
workspace_reset_request_id: 'reset-request',
workspace_resetting: true,
state: 'paused',
active_runs: '2',
},
});
expect(normalized).toMatchObject({
workflow_id: 'workflow-1',
generation: 5,
revision: 11,
workspace_epoch: 3,
workspace_reset_request_id: 'reset-request',
workspace_resetting: true,
state: 'paused',
active_count: 2,
can_resume: true,
});
});
});
describe('workflow control mutation responses', () => {
it('uses a lifecycle timeout long enough for durable setup and teardown', () => {
expect(WORKFLOW_CONTROL_REQUEST_TIMEOUT).toBe(5 * 60 * 1000);
});
it('rejects explicit success:false responses with the backend error', () => {
expect(() => assertWorkflowControlMutationSucceeded({
success: false,
error: 'control_revision_conflict',
state: 'never_started',
})).toThrow('control_revision_conflict');
});
it('returns successful status payloads unchanged', () => {
const response = { success: true, generation: 2, revision: 3 };
expect(assertWorkflowControlMutationSucceeded(response)).toBe(response);
});
it('preserves a successful Start graph and aliases in the typed snapshot', () => {
const response = {
success: true,
workflow_id: 'workflow-1',
generation: 2,
state: 'running',
revision: 3,
graph: {
graphVersion: 2,
nodes: [{ id: 'workflow-1:context:1', type: 'context' }],
edges: [{
id: 'context-edge',
source: 'workflow-1:context:1',
target: 'workflow-1:agent:1',
}],
},
aliases: {
'legacy-agent': 'workflow-1:agent:1',
},
};
const snapshot: WorkflowStartResult = normalizeWorkflowControlStatus(response);
expect(snapshot.graph).toEqual(response.graph);
expect(snapshot.aliases).toEqual(response.aliases);
});
it('extracts the authoritative snapshot carried by a success:false response', () => {
const current = status({ state: 'running', revision: 3 });
const response = {
success: false,
error: 'workflow_control_transition_pending',
workflow_id: 'workflow-1',
generation: 1,
state: 'pausing',
revision: 4,
can_start: false,
can_pause: false,
can_resume: false,
can_reset: true,
};
const snapshot = extractWorkflowControlStatusSnapshot(response);
expect(snapshot).toMatchObject({
workflow_id: 'workflow-1',
state: 'pausing',
revision: 4,
can_reset: true,
});
expect(mergeWorkflowControlStatus(current, snapshot!)).toBe(snapshot);
expect(() => assertWorkflowControlMutationSucceeded(response))
.toThrow('workflow_control_transition_pending');
});
it('does not mistake a generic mutation error for a control snapshot', () => {
expect(extractWorkflowControlStatusSnapshot({
success: false,
error: 'control_revision_conflict',
workflow_id: 'workflow-1',
})).toBeUndefined();
});
it('only retries Reset conflicts when the resynced snapshot still allows Reset', () => {
const conflict = new Error('control_revision_conflict');
expect(shouldRetryResetWorkflowAfterConflict(
conflict,
status({ state: 'starting', revision: 2, can_reset: true }),
)).toBe(true);
expect(shouldRetryResetWorkflowAfterConflict(
conflict,
status({ state: 'ready', revision: 3, can_reset: false }),
)).toBe(false);
expect(shouldRetryResetWorkflowAfterConflict(
new Error('workflow_control_transition_pending'),
status({ state: 'starting', revision: 2, can_reset: true }),
)).toBe(false);
});
it('does not confirm a phone-only reset merely because the workflow was already ready', () => {
expect(isWorkflowResetRecoveryConfirmed(status({
state: 'ready', revision: 3, workspace_epoch: 2,
workspace_reset_request_id: 'old-reset', workspace_resetting: false,
}), 3, new Set(['new-reset']))).toBe(false);
});
it.each(['ready', 'never_started'] as const)('recovers %s when the exact workspace reset completed', (state) => {
expect(isWorkflowResetRecoveryConfirmed(status({
state, revision: 3, workspace_epoch: 4,
workspace_reset_request_id: 'this-reset', workspace_resetting: false,
}), 3, new Set(['this-reset']))).toBe(true);
});
it('requires workspace cleanup to finish even when the request ID or revision matches', () => {
expect(isWorkflowResetRecoveryConfirmed(status({
state: 'ready', revision: 4, workspace_reset_request_id: 'this-reset', workspace_resetting: true,
}), 3, new Set(['this-reset']))).toBe(false);
});
it.each([3, 4])('does not confirm reset with unavailable workspace status at revision %s', (revision) => {
const unavailable = normalizeWorkflowControlStatus({
state: 'ready', revision, workspace_available: false,
workspace_reset_request_id: 'this-reset', workspace_resetting: false,
});
expect(unavailable.workspace_available).toBe(false);
expect(isWorkflowResetRecoveryConfirmed(unavailable, 3, new Set(['this-reset']))).toBe(false);
});
it('preserves recovery of ordinary resets after their lifecycle revision advances', () => {
expect(isWorkflowResetRecoveryConfirmed(status({ state: 'ready', revision: 4 }), 3, new Set())).toBe(true);
expect(isWorkflowResetRecoveryConfirmed(status({ state: 'resetting', revision: 4 }), 3, new Set())).toBe(false);
});
it.each([
['start', 'running'],
['pause', 'paused'],
['resume', 'running'],
['reset', 'ready'],
] satisfies Array<[WorkflowControlMutationAction, WorkflowControlState]>)(
'accepts an authoritative %s resync only after it reaches %s',
(action, stableState) => {
expect(isWorkflowControlMutationConfirmed(action, status({
state: stableState,
}))).toBe(true);
},
);
it.each([
['start', 'starting'],
['pause', 'pausing'],
['resume', 'resuming'],
['reset', 'resetting'],
] satisfies Array<[WorkflowControlMutationAction, WorkflowControlState]>)(
'does not treat the transitional %s state as confirmed',
(action, transitionalState) => {
expect(isWorkflowControlMutationConfirmed(action, status({
state: transitionalState,
}))).toBe(false);
},
);
});