Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

test(desktop): cover prewarm races and pending acknowledgement

Alfredo Lopezdf8f1130d81f
diff --git a/desktop-app/src/__tests__/appService.prewarm.test.ts b/desktop-app/src/__tests__/appService.prewarm.test.ts
index 91d4d4584..2fb75eeaa 100644
--- a/desktop-app/src/__tests__/appService.prewarm.test.ts
+++ b/desktop-app/src/__tests__/appService.prewarm.test.ts
@@ -338,12 +338,16 @@ describe('AppService.prewarmHost — bounded wake re-emission', () => {
).mockReturnValue(pendingSwitch)
mockPrewarmHost.mockResolvedValue({ status: 'active' })
+ await expect(svc.prewarmHost('first-host')).resolves.toEqual({
+ requested: true,
+ status: 'active',
+ })
const switching = svc.switchTeam('team-2')
await expect(svc.prewarmHost('chatllm')).resolves.toEqual({
requested: false,
skipped: 'auth-changed',
})
- expect(mockPrewarmHost).not.toHaveBeenCalled()
+ expect(mockPrewarmHost).toHaveBeenCalledTimes(1)
rejectSwitch(new Error('switch canceled'))
await expect(switching).rejects.toThrow('switch canceled')
@@ -351,6 +355,7 @@ describe('AppService.prewarmHost — bounded wake re-emission', () => {
requested: true,
status: 'active',
})
+ expect(mockPrewarmHost).toHaveBeenCalledTimes(2)
})
it('a transient session revision does not cancel the bounded wake loop', async () => {
@@ -367,6 +372,94 @@ describe('AppService.prewarmHost — bounded wake re-emission', () => {
expect(vi.getTimerCount()).toBe(0)
})
+ it('an internal team hop preserves the bounded wake loop and cooldown', async () => {
+ mockPrewarmHost
+ .mockResolvedValueOnce({ status: 'wake-requested' })
+ .mockResolvedValueOnce({ status: 'active' })
+ const svc = makeService()
+ const switchSessionToTeam = vi
+ .spyOn(
+ svc as unknown as { switchSessionToTeam: () => Promise<string> },
+ 'switchSessionToTeam'
+ )
+ .mockImplementation(async () => (svc as unknown as { sessionToken: string }).sessionToken)
+ let finishOperation!: () => void
+ const operation = new Promise<void>(resolve => {
+ finishOperation = resolve
+ })
+ let markOperationStarted!: () => void
+ const operationStarted = new Promise<void>(resolve => {
+ markOperationStarted = resolve
+ })
+
+ await svc.prewarmHost('chatllm')
+ const hop = (
+ svc as unknown as {
+ runWithTeamContext: (teamId: string, operation: () => Promise<void>) => Promise<void>
+ }
+ ).runWithTeamContext('team-2', () => {
+ markOperationStarted()
+ return operation
+ })
+ await operationStarted
+ expect(switchSessionToTeam).toHaveBeenCalledWith('team-2', expect.any(String))
+ expect(
+ (
+ svc as unknown as { prewarmAttemptAtByHostRef: Map<string, number> }
+ ).prewarmAttemptAtByHostRef.has('chatllm')
+ ).toBe(true)
+ await vi.advanceTimersByTimeAsync(10_000)
+ expect(mockPrewarmHost).toHaveBeenCalledTimes(2)
+ expect(vi.getTimerCount()).toBe(0)
+
+ finishOperation()
+ await hop
+ expect(switchSessionToTeam).toHaveBeenCalledWith('team-1', expect.any(String))
+ await expect(svc.prewarmHost('chatllm')).resolves.toEqual({
+ requested: false,
+ skipped: 'cooldown',
+ })
+ })
+
+ it('nested explicit transitions keep prewarm fenced until both rejected switches settle', async () => {
+ const rejectSwitches: Array<(error: Error) => void> = []
+ const svc = makeService()
+ vi.spyOn(
+ svc as unknown as { switchSessionToTeam: () => Promise<string> },
+ 'switchSessionToTeam'
+ ).mockImplementation(
+ () =>
+ new Promise<string>((_resolve, reject) => {
+ rejectSwitches.push(reject)
+ })
+ )
+ mockPrewarmHost.mockResolvedValue({ status: 'active' })
+
+ const firstSwitch = svc.switchTeam('team-2')
+ const secondSwitch = svc.switchTeam('team-3')
+ expect(rejectSwitches).toHaveLength(2)
+ await expect(svc.prewarmHost('chatllm')).resolves.toEqual({
+ requested: false,
+ skipped: 'auth-changed',
+ })
+
+ rejectSwitches[0](new Error('first switch rejected'))
+ await expect(firstSwitch).rejects.toThrow('first switch rejected')
+ await expect(svc.prewarmHost('chatllm')).resolves.toEqual({
+ requested: false,
+ skipped: 'auth-changed',
+ })
+ expect(mockPrewarmHost).not.toHaveBeenCalled()
+
+ rejectSwitches[1](new Error('second switch rejected'))
+ await expect(secondSwitch).rejects.toThrow('second switch rejected')
+ await expect(svc.prewarmHost('chatllm')).resolves.toEqual({
+ requested: true,
+ status: 'active',
+ })
+ expect(mockPrewarmHost).toHaveBeenCalledTimes(1)
+ })
+
it('a late prior response cannot clear the new session wake loop', async () => {
let completeOld!: (value: { status: string }) => void
const pendingOld = new Promise<{ status: string }>(resolve => {
@@ -397,6 +490,10 @@ describe('AppService.prewarmHost — bounded wake re-emission', () => {
const loops = (svc as unknown as { prewarmReemitLoopHostRefs: Set<string> })
.prewarmReemitLoopHostRefs
expect(loops.has('chatllm')).toBe(true)
+ await expect(svc.prewarmHost('chatllm')).resolves.toEqual({
+ requested: false,
+ skipped: 'cooldown',
+ })
;(
svc as unknown as { prewarmAttemptAtByHostRef: Map<string, number> }
).prewarmAttemptAtByHostRef.delete('chatllm')
diff --git a/desktop-app/ui/src/hooks/domain/__tests__/useAgentChatController.crossChat.test.tsx b/desktop-app/ui/src/hooks/domain/__tests__/useAgentChatController.crossChat.test.tsx
index 80b572cb4..64e06d3e8 100644
--- a/desktop-app/ui/src/hooks/domain/__tests__/useAgentChatController.crossChat.test.tsx
+++ b/desktop-app/ui/src/hooks/domain/__tests__/useAgentChatController.crossChat.test.tsx
@@ -191,6 +191,11 @@ function AgentChatHarness() {
<div data-testid="active-chat-id">{vm.activeChatId || ''}</div>
<div data-testid="agent-sending">{String(vm.agentSending)}</div>
<div data-testid="chat-message-count">{vm.chatMessages.length}</div>
+ {vm.chatMessages.map(message => (
+ <div key={message.id} data-testid="chat-message-row">
+ {message.content}
+ </div>
+ ))}
<div data-testid="chat-list-ids">{vm.chatList.map(chat => chat.id).join(',')}</div>
<div data-testid="latest-list-ids">
{vm.latestChatSessions.map(chat => chat.id).join(',')}
@@ -315,6 +320,55 @@ describe('useAgentChatController (cross-chat, migrated)', () => {
await waitFor(() => expect(progressHandlers.size).toBe(0))
})
+ it('persists the outgoing row before invoking the host and leaves it visible while the acknowledgement is pending', async () => {
+ const { invokeHostMessage, upsertMessages, progressHandlers } = installClerumHarness()
+ let acknowledge!: (result: { taskId: string; status: string }) => void
+ invokeHostMessage.mockImplementationOnce(
+ () =>
+ new Promise(resolve => {
+ acknowledge = resolve
+ })
+ )
+
+ render(
+ <AgentTaskTrackerProvider>
+ <AgentChatHarness />
+ </AgentTaskTrackerProvider>
+ )
+ fireEvent.click(screen.getByRole('button', { name: 'Create chat' }))
+ await waitFor(() => expect(screen.getByTestId('active-chat-id').textContent).not.toBe(''))
+
+ fireEvent.click(screen.getByRole('button', { name: 'Send message' }))
+ await waitFor(() => expect(invokeHostMessage).toHaveBeenCalledTimes(1))
+
+ expect(upsertMessages.mock.invocationCallOrder[0]).toBeLessThan(
+ invokeHostMessage.mock.invocationCallOrder[0]!
+ )
+ expect(upsertMessages.mock.calls[0]?.[2]?.[0]).toMatchObject({
+ role: 'user',
+ content: 'hello',
+ })
+ expect(upsertMessages.mock.calls[0]?.[2]?.[0]).not.toHaveProperty('task_id')
+ expect(screen.getByTestId('chat-message-row').textContent).toBe('hello')
+ expect(screen.getByTestId('send-state').textContent).toBe('pending')
+ expect(progressHandlers.size).toBe(0)
+
+ acknowledge({ taskId: 'acknowledged-task', status: 'pending' })
+ await waitFor(() => expect(screen.getByTestId('send-state').textContent).toBe('settled'))
+ await waitFor(() => expect(progressHandlers.has('acknowledged-task')).toBe(true))
+ expect(upsertMessages.mock.calls[1]?.[2]?.[0]).toMatchObject({
+ id: (upsertMessages.mock.calls[0]?.[2]?.[0] as { id: string }).id,
+ task_id: 'acknowledged-task',
+ })
+ expect(screen.getByTestId('chat-message-row').textContent).toBe('hello')
+
+ await progressHandlers.get('acknowledged-task')?.({
+ type: 'terminal',
+ data: { status: 'completed' },
+ } as TaskProgressStreamEvent)
+ await waitFor(() => expect(progressHandlers.size).toBe(0))
+ })
+
it('keeps an outgoing message visible across a Host switch while its POST is pending', async () => {
const { invokeHostMessage, upsertMessages } = installClerumHarness()
const persistOutgoingToMap = upsertMessages.getMockImplementation()