Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

29.0 KB
Raw Blame
import { configureStore } from '@reduxjs/toolkit';
import { beforeEach, describe, expect, it, vi } from 'vitest';

import { threadApi } from '../../services/api/threadApi';
import { CoreRpcError } from '../../services/coreRpcClient';
import type { Thread, ThreadMessage } from '../../types/thread';
import threadReducer, {
  addInferenceResponse,
  addMessageLocal,
  applyChannelEvent,
  clearAllThreads,
  clearSelectedThread,
  clearStaleThread,
  clearThreadInferenceActive,
  deleteThread,
  generateThreadTitleIfNeeded,
  loadThreadMessages,
  loadThreads,
  markThreadInferenceActive,
  setActiveThread,
  setSelectedThread,
  setWelcomeThreadId,
  THREAD_NOT_FOUND_MESSAGE,
  updateThreadTitle,
} from '../threadSlice';

vi.mock('../../services/api/threadApi', () => ({
  threadApi: {
    createNewThread: vi.fn(),
    getThreads: vi.fn(),
    getThreadMessages: vi.fn(),
    appendMessage: vi.fn(),
    deleteThread: vi.fn(),
    generateTitleIfNeeded: vi.fn(),
    updateMessage: vi.fn(),
    updateLabels: vi.fn(),
    updateTitle: vi.fn(),
    purge: vi.fn(),
  },
}));

const mockedThreadApi = vi.mocked(threadApi);

function createStore() {
  return configureStore({ reducer: { thread: threadReducer } });
}

function makeThread(overrides: Partial<Thread> = {}): Thread {
  return {
    id: 't-1',
    title: 'Untitled',
    chatId: null,
    isActive: false,
    messageCount: 0,
    lastMessageAt: '2026-01-01T00:00:00.000Z',
    createdAt: '2026-01-01T00:00:00.000Z',
    labels: [],
    ...overrides,
  };
}

function makeMessage(overrides: Partial<ThreadMessage> = {}): ThreadMessage {
  return {
    id: 'm-1',
    content: 'hello',
    type: 'text',
    extraMetadata: {},
    sender: 'user',
    createdAt: '2026-01-01T00:00:00.000Z',
    ...overrides,
  };
}

describe('threadSlice synchronous reducers', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('starts with the expected initial state', () => {
    const store = createStore();
    const state = store.getState().thread;
    expect(state.threads).toEqual([]);
    expect(state.selectedThreadId).toBeNull();
    expect(state.activeThreadIds).toEqual({});
    expect(state.messagesByThreadId).toEqual({});
    expect(state.messages).toEqual([]);
    expect(state.isLoadingThreads).toBe(false);
    expect(state.isLoadingMessages).toBe(false);
  });

  it('deletes a thread from legacy persisted state without channel activity', () => {
    const current = threadReducer(undefined, { type: '@@test/init' });
    const legacyState = {
      ...current,
      channelActivityByThreadId: undefined,
    } as unknown as typeof current;

    expect(() =>
      threadReducer(
        legacyState,
        deleteThread.fulfilled({ threadId: 't-legacy' }, 'request-1', 't-legacy')
      )
    ).not.toThrow();
  });

  it('applies provider reactions only to the exact OpenHuman row and persists read state in metadata', async () => {
    const store = createStore();
    const message = makeMessage({
      id: 'user:row-42',
      extraMetadata: {
        channelActivity: {
          reactions: { 'persisted-reaction': { actorId: 'bob', value: '🎉' } },
          readReceipts: { 'persisted-receipt': { actorId: 'carol', timestamp: 123 } },
        },
      },
    });
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({ messages: [message], count: 1 });
    await store.dispatch(loadThreadMessages('channel:telegram/alice/room-1'));

    const event = {
      client_id: 'channel-runtime',
      thread_id: 'channel:telegram/alice/room-1',
      request_id: 'event-9',
      openhuman_message_id: 'user:row-42',
      channel_event: {
        version: 2,
        eventId: 'event-9',
        sourceEventId: null,
        sourceTimestamp: null,
        channel: { id: 'telegram', accountId: 'bot-1' },
        conversation: {
          kind: 'group',
          id: 'room-1',
          parentId: null,
          scopeId: null,
          threadId: null,
          topicId: null,
        },
        type: 'reaction_added',
        messageId: 'provider-message-42',
        actor: { id: 'alice', altIds: [], name: null, isBot: false, roles: [] },
        reaction: { value: '🔥', customEmojiId: null },
      },
    } as const satisfies Parameters<typeof applyChannelEvent>[0];
    store.dispatch(applyChannelEvent(event));

    expect(
      store.getState().thread.messagesByThreadId['channel:telegram/alice/room-1']?.[0]
        ?.extraMetadata?.channelActivity
    ).toEqual({
      reactions: [
        { actorId: 'bob', value: '🎉' },
        { actorId: 'alice', value: '🔥' },
      ],
      readReceipts: [{ actorId: 'carol', timestamp: 123 }],
    });
    expect(
      store.getState().thread.messagesByThreadId['channel:telegram/alice/room-1']?.[0]?.id
    ).toBe('user:row-42');
  });

  // [#1123] setWelcomeThreadId is now a true no-op — kept for TS compat but
  // state.welcomeThreadId must never be mutated by this action.
  it('setWelcomeThreadId is a no-op — state.welcomeThreadId stays null', () => {
    const store = createStore();
    store.dispatch(setWelcomeThreadId());
    expect(store.getState().thread.welcomeThreadId).toBeNull();
  });

  it('setSelectedThread copies cached messages into the visible list', async () => {
    const store = createStore();
    const cached = [makeMessage({ id: 'm-1' }), makeMessage({ id: 'm-2' })];

    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({
      messages: cached,
      count: cached.length,
    });
    await store.dispatch(loadThreadMessages('t-1'));

    store.dispatch(setSelectedThread('t-1'));
    const state = store.getState().thread;
    expect(state.selectedThreadId).toBe('t-1');
    expect(state.messages).toEqual(cached);
    expect(state.messagesError).toBeNull();
  });

  it('setSelectedThread resets messages when cache is empty', () => {
    const store = createStore();
    store.dispatch(setSelectedThread('missing'));
    const state = store.getState().thread;
    expect(state.selectedThreadId).toBe('missing');
    expect(state.messages).toEqual([]);
  });

  it('clearSelectedThread clears visible selection but keeps cache', async () => {
    const store = createStore();
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({
      messages: [makeMessage()],
      count: 1,
    });
    await store.dispatch(loadThreadMessages('t-1'));
    store.dispatch(setSelectedThread('t-1'));

    store.dispatch(clearSelectedThread());
    const state = store.getState().thread;
    expect(state.selectedThreadId).toBeNull();
    expect(state.messages).toEqual([]);
    expect(state.messagesByThreadId['t-1']).toHaveLength(1);
  });

  it('setActiveThread marks a thread active; null clears the whole set', () => {
    const store = createStore();
    store.dispatch(setActiveThread('t-active'));
    expect(store.getState().thread.activeThreadIds).toEqual({ 't-active': true });
    store.dispatch(setActiveThread(null));
    expect(store.getState().thread.activeThreadIds).toEqual({});
  });

  it('tracks multiple concurrently-active threads independently', () => {
    const store = createStore();
    store.dispatch(markThreadInferenceActive('t-1'));
    store.dispatch(markThreadInferenceActive('t-2'));
    expect(store.getState().thread.activeThreadIds).toEqual({ 't-1': true, 't-2': true });
    // Clearing one leaves the other running — the core of parallel inference.
    store.dispatch(clearThreadInferenceActive('t-1'));
    expect(store.getState().thread.activeThreadIds).toEqual({ 't-2': true });
  });

  it('clearAllThreads wipes threads, messages, and selection', async () => {
    const store = createStore();
    mockedThreadApi.getThreads.mockResolvedValueOnce({
      threads: [makeThread({ id: 't-1' })],
      count: 1,
    });
    await store.dispatch(loadThreads());
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({
      messages: [makeMessage()],
      count: 1,
    });
    await store.dispatch(loadThreadMessages('t-1'));
    store.dispatch(setSelectedThread('t-1'));
    store.dispatch(setActiveThread('t-1'));

    const selectionVersion = store.getState().thread.selectionIntentVersion;
    store.dispatch(clearAllThreads());
    const state = store.getState().thread;
    expect(state.threads).toEqual([]);
    expect(state.messagesByThreadId).toEqual({});
    expect(state.selectedThreadId).toBeNull();
    expect(state.activeThreadIds).toEqual({});
    expect(state.messages).toEqual([]);
    expect(state.selectionIntentVersion).toBeGreaterThan(selectionVersion);
  });

  it('clearStaleThread removes stale selection, cache, and active id', async () => {
    const store = createStore();
    mockedThreadApi.getThreads.mockResolvedValueOnce({
      threads: [makeThread({ id: 't-1' }), makeThread({ id: 't-2' })],
      count: 2,
    });
    await store.dispatch(loadThreads());
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({
      messages: [makeMessage()],
      count: 1,
    });
    await store.dispatch(loadThreadMessages('t-1'));
    store.dispatch(setSelectedThread('t-1'));
    store.dispatch(setActiveThread('t-1'));

    const selectionVersion = store.getState().thread.selectionIntentVersion;
    store.dispatch(clearStaleThread('t-1'));

    const state = store.getState().thread;
    expect(state.threads.map(thread => thread.id)).toEqual(['t-2']);
    expect(state.messagesByThreadId['t-1']).toBeUndefined();
    expect(state.selectedThreadId).toBeNull();
    expect(state.selectionIntentVersion).toBeGreaterThan(selectionVersion);
    expect(state.activeThreadIds).toEqual({});
    expect(state.messages).toEqual([]);
  });
});

describe('threadSlice loadThreads thunk', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('does not restore threads from a load superseded by clearing all threads', async () => {
    const store = createStore();
    let resolveThreads!: (value: { threads: Thread[]; count: number }) => void;
    mockedThreadApi.getThreads.mockImplementationOnce(
      () => new Promise(resolve => (resolveThreads = resolve))
    );

    const request = store.dispatch(loadThreads());
    store.dispatch(clearAllThreads());
    resolveThreads({ threads: [makeThread({ id: 'stale' })], count: 1 });
    await request;

    expect(store.getState().thread.threads).toEqual([]);
    expect(store.getState().thread.selectedThreadId).toBeNull();
  });

  it('does not restore a cleared stale thread from an older list response', async () => {
    const store = createStore();
    mockedThreadApi.getThreads.mockResolvedValueOnce({
      threads: [makeThread({ id: 't-1' }), makeThread({ id: 't-2' })],
      count: 2,
    });
    await store.dispatch(loadThreads());
    store.dispatch(setSelectedThread('t-1'));

    let resolveThreads!: (value: { threads: Thread[]; count: number }) => void;
    mockedThreadApi.getThreads.mockImplementationOnce(
      () => new Promise(resolve => (resolveThreads = resolve))
    );
    const request = store.dispatch(loadThreads());
    store.dispatch(clearStaleThread('t-1'));
    resolveThreads({ threads: [makeThread({ id: 't-1' }), makeThread({ id: 't-2' })], count: 2 });
    await request;

    expect(store.getState().thread.threads.map(thread => thread.id)).toEqual(['t-2']);
    expect(store.getState().thread.selectedThreadId).toBeNull();
  });

  it('sets isLoadingThreads while pending and stores threads on fulfilled', async () => {
    const store = createStore();
    const payload = { threads: [makeThread({ id: 'a' })], count: 1 };
    mockedThreadApi.getThreads.mockImplementationOnce(async () => {
      expect(store.getState().thread.isLoadingThreads).toBe(true);
      return payload;
    });

    await store.dispatch(loadThreads());
    const state = store.getState().thread;
    expect(state.isLoadingThreads).toBe(false);
    expect(state.threads).toEqual(payload.threads);
  });

  it('clears loading on rejection', async () => {
    const store = createStore();
    mockedThreadApi.getThreads.mockRejectedValueOnce(new Error('network down'));

    const result = await store.dispatch(loadThreads());
    expect(result.type).toBe('thread/loadThreads/rejected');
    expect(store.getState().thread.isLoadingThreads).toBe(false);
  });

  it('preserves a newer selection when an older thread-list response omits it', async () => {
    const store = createStore();
    let resolveThreads: ((value: { threads: Thread[]; count: number }) => void) | undefined;
    mockedThreadApi.getThreads.mockImplementationOnce(
      () => new Promise(resolve => (resolveThreads = resolve))
    );

    const request = store.dispatch(loadThreads());
    store.dispatch(setSelectedThread('worker-created-after-request'));
    resolveThreads?.({ threads: [makeThread({ id: 'existing-thread' })], count: 1 });
    await request;

    expect(store.getState().thread.selectedThreadId).toBe('worker-created-after-request');
  });
});

describe('threadSlice loadThreadMessages thunk', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('hydrates messagesByThreadId and mirrors visible list when selected', async () => {
    const store = createStore();
    store.dispatch(setSelectedThread('t-1'));
    const messages = [makeMessage({ id: 'a' }), makeMessage({ id: 'b' })];
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({ messages, count: messages.length });

    await store.dispatch(loadThreadMessages('t-1'));
    const state = store.getState().thread;
    expect(state.messagesByThreadId['t-1']).toEqual(messages);
    expect(state.messages).toEqual(messages);
    expect(state.isLoadingMessages).toBe(false);
    expect(state.messagesError).toBeNull();
  });

  it('preserves old message identities and order when rehydrating after the next turn', async () => {
    const store = createStore();
    store.dispatch(setSelectedThread('t-1'));
    const history = [
      makeMessage({ id: 'first-user', sender: 'user' }),
      makeMessage({ id: 'first-answer', sender: 'agent', content: 'First answer' }),
    ];
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({ messages: history, count: 2 });
    await store.dispatch(loadThreadMessages('t-1'));
    const original = store.getState().thread.messages;
    const next = [
      ...history.map(message => ({ ...message, extraMetadata: { ...message.extraMetadata } })),
      makeMessage({ id: 'try-now', sender: 'user', content: 'try now' }),
    ];
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({ messages: next, count: 3 });
    await store.dispatch(loadThreadMessages('t-1'));
    const refreshed = store.getState().thread.messages;
    expect(refreshed.map(message => message.id)).toEqual(['first-user', 'first-answer', 'try-now']);
    expect(refreshed[0]).toBe(original[0]);
    expect(refreshed[1]).toBe(original[1]);
  });

  it('does not overwrite visible messages when loading a non-selected thread', async () => {
    const store = createStore();
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({
      messages: [makeMessage({ id: 'x' })],
      count: 1,
    });
    await store.dispatch(loadThreadMessages('t-1'));
    store.dispatch(setSelectedThread('t-1'));

    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({
      messages: [makeMessage({ id: 'y', content: 'other thread' })],
      count: 1,
    });
    await store.dispatch(loadThreadMessages('t-2'));

    const state = store.getState().thread;
    expect(state.messagesByThreadId['t-2']).toHaveLength(1);
    expect(state.messagesByThreadId['t-2'][0].content).toBe('other thread');
    // Visible messages stayed pinned to t-1.
    expect(state.messages).toHaveLength(1);
    expect(state.messages[0].id).toBe('x');
  });

  it('records messagesError on rejection', async () => {
    const store = createStore();
    mockedThreadApi.getThreadMessages.mockRejectedValueOnce(new Error('boom'));
    await store.dispatch(loadThreadMessages('t-1'));
    const state = store.getState().thread;
    expect(state.isLoadingMessages).toBe(false);
    expect(state.messagesError).toBe('boom');
  });

  it('merges a locally-appended message not yet reflected in the fetch instead of wiping it out', async () => {
    // Simulates a rehydrate racing a concurrent append on the same thread
    // (e.g. useWorkflowBuilderChat's copilot rehydrate vs. an auto-sent
    // repair/build turn): the local message already persisted server-side
    // (it only lands via a `.fulfilled` reducer) but this particular GET's
    // snapshot predates it.
    const store = createStore();
    const persisted = makeMessage({ id: 'local-new', content: 'just sent', sender: 'user' });
    mockedThreadApi.appendMessage.mockResolvedValueOnce(persisted);
    await store.dispatch(addMessageLocal({ threadId: 't-1', message: persisted }));
    expect(store.getState().thread.messagesByThreadId['t-1']).toEqual([persisted]);

    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({
      messages: [makeMessage({ id: 'srv-older', content: 'older, server-known' })],
      count: 1,
    });
    await store.dispatch(loadThreadMessages('t-1'));

    const merged = store.getState().thread.messagesByThreadId['t-1'];
    expect(merged.map(m => m.id)).toEqual(['srv-older', 'local-new']);
  });

  it('does not duplicate a message already present in the fetched snapshot', async () => {
    const store = createStore();
    const shared = makeMessage({ id: 'shared' });
    const persisted = makeMessage({ id: 'shared', content: 'server version' });
    // Prime the cache with a local entry sharing the fetched id.
    mockedThreadApi.appendMessage.mockResolvedValueOnce(shared);
    await store.dispatch(addMessageLocal({ threadId: 't-1', message: shared }));

    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({ messages: [persisted], count: 1 });
    await store.dispatch(loadThreadMessages('t-1'));

    const merged = store.getState().thread.messagesByThreadId['t-1'];
    expect(merged).toHaveLength(1);
    expect(merged[0].content).toBe('server version');
  });

  it('clears stale thread state and rejects with THREAD_NOT_FOUND_MESSAGE when the thread was deleted', async () => {
    const store = createStore();
    store.dispatch(setSelectedThread('t-1'));
    mockedThreadApi.getThreadMessages.mockRejectedValueOnce(
      new CoreRpcError('thread t-1 not found', 'thread_not_found', undefined, {
        kind: 'ThreadNotFound',
        thread_id: 't-1',
      })
    );
    mockedThreadApi.getThreads.mockResolvedValueOnce({ threads: [], count: 0 });

    const result = await store.dispatch(loadThreadMessages('t-1'));

    expect(result.type).toBe('thread/loadThreadMessages/rejected');
    expect(result.payload).toBe(THREAD_NOT_FOUND_MESSAGE);
    expect(store.getState().thread.selectedThreadId).toBeNull();
    expect(store.getState().thread.messagesByThreadId['t-1']).toBeUndefined();
  });
});

describe('threadSlice addMessageLocal thunk', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('requests a stable title refresh after persisting a user message', async () => {
    const store = createStore();
    const persisted = makeMessage({ id: 'srv-user', content: 'Summarize my latest 5 emails' });
    const titledThread = makeThread({ id: 't-1', title: 'Summarize my latest 5 emails' });
    mockedThreadApi.appendMessage.mockResolvedValueOnce(persisted);
    mockedThreadApi.generateTitleIfNeeded.mockResolvedValueOnce(titledThread);
    mockedThreadApi.getThreads.mockResolvedValueOnce({ threads: [titledThread], count: 1 });

    const result = await store.dispatch(
      addMessageLocal({ threadId: 't-1', message: makeMessage({ content: persisted.content }) })
    );

    // The title refresh is fire-and-forget — flush the microtask queue so the
    // generateThreadTitleIfNeeded and loadThreads thunks settle in the store.
    await vi.waitFor(() => {
      expect(mockedThreadApi.generateTitleIfNeeded).toHaveBeenCalledWith('t-1', undefined);
    });
    await vi.waitFor(() => {
      expect(store.getState().thread.threads[0]?.title).toBe('Summarize my latest 5 emails');
    });

    expect(result.type).toBe('thread/addMessageLocal/fulfilled');
    expect(store.getState().thread.messagesByThreadId['t-1']).toEqual([persisted]);
  });

  it('does not fail user message persistence when title refresh fails', async () => {
    const store = createStore();
    const persisted = makeMessage({ id: 'srv-user' });
    mockedThreadApi.appendMessage.mockResolvedValueOnce(persisted);
    mockedThreadApi.generateTitleIfNeeded.mockRejectedValueOnce(new Error('title offline'));

    const result = await store.dispatch(addMessageLocal({ threadId: 't-1', message: persisted }));

    expect(result.type).toBe('thread/addMessageLocal/fulfilled');
    expect(store.getState().thread.messagesByThreadId['t-1']).toEqual([persisted]);
  });

  it('does not request title refresh for assistant messages', async () => {
    const store = createStore();
    const persisted = makeMessage({ id: 'srv-agent', sender: 'agent', content: 'ack' });
    mockedThreadApi.appendMessage.mockResolvedValueOnce(persisted);

    await store.dispatch(addMessageLocal({ threadId: 't-1', message: persisted }));

    expect(mockedThreadApi.generateTitleIfNeeded).not.toHaveBeenCalled();
  });

  it('clears stale thread state and does not retry append on ThreadNotFound', async () => {
    const store = createStore();
    mockedThreadApi.getThreads.mockResolvedValueOnce({
      threads: [makeThread({ id: 't-1' })],
      count: 1,
    });
    await store.dispatch(loadThreads());
    store.dispatch(setSelectedThread('t-1'));
    store.dispatch(setActiveThread('t-1'));

    mockedThreadApi.appendMessage.mockRejectedValueOnce(
      new CoreRpcError('thread t-1 not found', 'thread_not_found', undefined, {
        kind: 'ThreadNotFound',
        thread_id: 't-1',
      })
    );
    mockedThreadApi.getThreads.mockResolvedValueOnce({ threads: [], count: 0 });

    const result = await store.dispatch(
      addMessageLocal({ threadId: 't-1', message: makeMessage() })
    );

    expect(result.type).toBe('thread/addMessageLocal/rejected');
    expect(result.payload).toBe(THREAD_NOT_FOUND_MESSAGE);
    expect(mockedThreadApi.appendMessage).toHaveBeenCalledTimes(1);
    expect(mockedThreadApi.generateTitleIfNeeded).not.toHaveBeenCalled();
    expect(mockedThreadApi.getThreads).toHaveBeenCalledTimes(2);
    expect(store.getState().thread.selectedThreadId).toBeNull();
    expect(store.getState().thread.activeThreadIds).toEqual({});
  });
});

describe('threadSlice addInferenceResponse thunk', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('appends to the supplied thread regardless of active/selected state', async () => {
    const store = createStore();
    const persisted = makeMessage({ id: 'srv-1', sender: 'agent', content: 'ack' });
    mockedThreadApi.appendMessage.mockResolvedValueOnce(persisted);

    const result = await store.dispatch(addInferenceResponse({ content: 'ack', threadId: 't-1' }));

    expect(result.type).toBe('thread/addInferenceResponse/fulfilled');
    const state = store.getState().thread;
    expect(state.messagesByThreadId['t-1']).toEqual([persisted]);
    // Active markers must not be mutated by this thunk — only ChatRuntimeProvider clears them.
    expect(state.activeThreadIds).toEqual({});
  });

  it('replaces a cached entry that already carries the persisted id instead of duplicating it (#5933)', async () => {
    // A core-initiated turn's reply is persisted by the core under
    // `agent:<run_id>` and announced afterwards; a thread reload can fetch that
    // row before our own same-id append resolves.
    const store = createStore();
    store.dispatch(setSelectedThread('t-1'));
    const coreRow = makeMessage({ id: 'agent:run-1', sender: 'agent', content: 'from core' });
    mockedThreadApi.getThreadMessages.mockResolvedValueOnce({ messages: [coreRow], count: 1 });
    await store.dispatch(loadThreadMessages('t-1'));

    mockedThreadApi.appendMessage.mockResolvedValueOnce(coreRow);
    await store.dispatch(
      addInferenceResponse({ content: 'from core', threadId: 't-1', messageId: 'agent:run-1' })
    );

    const state = store.getState().thread;
    expect(state.messagesByThreadId['t-1']).toEqual([coreRow]);
    expect(state.messages).toEqual([coreRow]);
  });

  it('falls back to the selected thread when no threadId is supplied', async () => {
    // Under parallel inference there is no single "active" thread to fall back
    // to, so the legacy fallback target is now the selected thread.
    const store = createStore();
    store.dispatch(setSelectedThread('t-selected'));
    mockedThreadApi.appendMessage.mockResolvedValueOnce(makeMessage({ sender: 'agent' }));

    await store.dispatch(addInferenceResponse({ content: 'ack' }));
    expect(mockedThreadApi.appendMessage).toHaveBeenCalledWith(
      't-selected',
      expect.objectContaining({ sender: 'agent', content: 'ack' })
    );
    expect(store.getState().thread.selectedThreadId).toBe('t-selected');
  });

  it('rejects cleanly when neither threadId nor a selected thread is set', async () => {
    const store = createStore();
    const result = await store.dispatch(addInferenceResponse({ content: 'ack' }));
    expect(result.type).toBe('thread/addInferenceResponse/rejected');
    expect(mockedThreadApi.appendMessage).not.toHaveBeenCalled();
  });

  it('clears stale active thread when assistant append returns ThreadNotFound', async () => {
    const store = createStore();
    store.dispatch(setSelectedThread('t-active'));
    store.dispatch(markThreadInferenceActive('t-active'));
    mockedThreadApi.appendMessage.mockRejectedValueOnce(
      new CoreRpcError('thread t-active not found', 'thread_not_found', undefined, {
        kind: 'ThreadNotFound',
        thread_id: 't-active',
      })
    );
    mockedThreadApi.getThreads.mockResolvedValueOnce({ threads: [], count: 0 });

    const result = await store.dispatch(addInferenceResponse({ content: 'ack' }));

    expect(result.type).toBe('thread/addInferenceResponse/rejected');
    expect(result.payload).toBe(THREAD_NOT_FOUND_MESSAGE);
    expect(mockedThreadApi.appendMessage).toHaveBeenCalledTimes(1);
    expect(store.getState().thread.activeThreadIds).toEqual({});
  });
});

describe('threadSlice generateThreadTitleIfNeeded thunk', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('clears stale thread state and refreshes list on ThreadNotFound', async () => {
    const store = createStore();
    mockedThreadApi.getThreads.mockResolvedValueOnce({
      threads: [makeThread({ id: 't-1' })],
      count: 1,
    });
    await store.dispatch(loadThreads());
    store.dispatch(setSelectedThread('t-1'));

    mockedThreadApi.generateTitleIfNeeded.mockRejectedValueOnce(
      new CoreRpcError('thread t-1 not found', 'thread_not_found', undefined, {
        kind: 'ThreadNotFound',
        thread_id: 't-1',
      })
    );
    mockedThreadApi.getThreads.mockResolvedValueOnce({ threads: [], count: 0 });

    const result = await store.dispatch(generateThreadTitleIfNeeded({ threadId: 't-1' }));

    expect(result.type).toBe('thread/generateThreadTitleIfNeeded/rejected');
    expect(result.payload).toBe(THREAD_NOT_FOUND_MESSAGE);
    expect(mockedThreadApi.generateTitleIfNeeded).toHaveBeenCalledTimes(1);
    expect(mockedThreadApi.getThreads).toHaveBeenCalledTimes(2);
    expect(store.getState().thread.selectedThreadId).toBeNull();
  });
});

describe('threadSlice updateThreadTitle thunk', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('replaces the thread in state on fulfilled', async () => {
    const store = createStore();
    const original = makeThread({ id: 't-1', title: 'Old title' });
    const updated = makeThread({ id: 't-1', title: 'Invoice follow-up' });

    mockedThreadApi.getThreads.mockResolvedValueOnce({ threads: [original], count: 1 });
    await store.dispatch(loadThreads());

    mockedThreadApi.updateTitle.mockResolvedValueOnce(updated);
    const result = await store.dispatch(
      updateThreadTitle({ threadId: 't-1', title: 'Invoice follow-up' })
    );

    expect(result.type).toBe('thread/updateThreadTitle/fulfilled');
    expect(mockedThreadApi.updateTitle).toHaveBeenCalledWith('t-1', 'Invoice follow-up');
    const state = store.getState().thread;
    expect(state.threads[0].title).toBe('Invoice follow-up');
  });

  it('does not mutate other threads when one title is updated', async () => {
    const store = createStore();
    const t1 = makeThread({ id: 't-1', title: 'Thread one' });
    const t2 = makeThread({ id: 't-2', title: 'Thread two' });
    const t1Updated = makeThread({ id: 't-1', title: 'Renamed one' });

    mockedThreadApi.getThreads.mockResolvedValueOnce({ threads: [t1, t2], count: 2 });
    await store.dispatch(loadThreads());

    mockedThreadApi.updateTitle.mockResolvedValueOnce(t1Updated);
    await store.dispatch(updateThreadTitle({ threadId: 't-1', title: 'Renamed one' }));

    const state = store.getState().thread;
    expect(state.threads.find(t => t.id === 't-1')?.title).toBe('Renamed one');
    expect(state.threads.find(t => t.id === 't-2')?.title).toBe('Thread two');
  });

  it('rejects with an error message when the API fails', async () => {
    const store = createStore();
    mockedThreadApi.updateTitle.mockRejectedValueOnce(new Error('network error'));

    const result = await store.dispatch(updateThreadTitle({ threadId: 't-1', title: 'New title' }));

    expect(result.type).toBe('thread/updateThreadTitle/rejected');
    expect(result.payload).toBe('network error');
  });
});