Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

17.7 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import { HistoryViewController, HistoryViewHandoff, projectHistoryView } from '@cindy/maker-shared/message-window';
import { appendOptimisticUserMessage, confirmedHistoryUserClientIds, projectOptimisticUserMessages, reconcileOptimisticUserMessages, repliedHistoryUserClientIds } from '../session/optimisticUserMessages';
import { buildMobileHistoryRenderItems } from '../session/mobileHistoryRender';
import { buildMobileMessageRenderItems } from '../session/messageRenderModel';
import { buildPendingSendItems, mergePendingSendItems } from '../session/pendingSendItems';
import { settleEnqueueResult, type QueueSettlingInput } from '../session/queueSettling';
import type { QueuedRemoteMessage, RemoteMessage } from '../session/types';

const none: ReadonlySet<string> = new Set();
const queued = {
  clientId: 'sent', text: 'hello',
  chatMessage: { clientId: 'sent', role: 'user', content: 'hello', createdAt: '2030-01-01T00:00:00Z' },
} as QueuedRemoteMessage;
const echo: RemoteMessage = {
  id: 'db-sent', clientId: 'sent', sessionId: 's', role: 'user', content: 'authoritative hello',
  createdAt: '2026-09-17T00:00:00Z', toolUseId: null, agentMeta: null,
};

const queueInput = (current: readonly QueuedRemoteMessage[] = [], overrides: Partial<QueueSettlingInput<QueuedRemoteMessage>> = {}): QueueSettlingInput<QueuedRemoteMessage> => ({
  previous: [queued], current, previousSteeringClientIds: none, currentSteeringClientIds: none,
  hiddenClientIds: none, locallyRemovedClientIds: none, ...overrides,
});

describe('sent message handoff', () => {
  it.each([false, true])('places a late harness boundary before the reserved send (history ready=%s)', async (ready) => {
    const previous: RemoteMessage = { ...echo, id: 'previous', clientId: 'previous', role: 'assistant',
      createdAt: '2026-09-16T23:59:00Z' };
    const boundary: RemoteMessage = { ...echo, id: 'switch', clientId: 'switch', role: 'agent_switch',
      content: { fromAgentKind: 'cc', toAgentKind: 'codex' }, createdAt: '2026-09-16T23:59:59Z' };
    let history = [previous];
    const view = new HistoryViewController<RemoteMessage>({
      page: async () => ({ version: 1, items: projectHistoryView(history, false), hasMore: false, nextCursor: null }),
      details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
      expanded: async () => undefined,
    });
    if (ready) await view.refresh();
    let slots = appendOptimisticUserMessage([], [previous], queued, 's');
    const raw = [previous, boundary];
    const handoff = new HistoryViewHandoff<RemoteMessage>(() => false);
    const render = () => {
      const snapshot = view.getSnapshot();
      const state = handoff.reconcile(snapshot, raw);
      slots = reconcileOptimisticUserMessages(slots, raw, new Set(['sent']), confirmedHistoryUserClientIds(snapshot, raw));
      const messages = projectOptimisticUserMessages(state.messages, slots);
      return (snapshot.ready ? buildMobileHistoryRenderItems({ view, snapshot, messages,
        pendingHandoff: state.pending, staleTail: state.tail,
        localUserClientIds: new Set(slots.map((entry) => entry.message.clientId)), streaming: false, sessionId: 's' })
        : buildMobileMessageRenderItems(messages, { preserveSourceOrder: true })).map((item) => item.key);
    };
    const expected = ['message-previous', 'message-switch', 'message-sent'];
    expect(projectOptimisticUserMessages(raw, slots).map((message) => message.clientId))
      .toEqual(['previous', 'switch', 'sent']);
    if (!ready) expect(render()).toEqual(expected);
    history = [previous, boundary];
    await view.refresh();
    expect(render()).toEqual(expected);
    raw.push(echo);
    expect(render()).toEqual(expected);
    history = [...raw];
    await view.refresh();
    expect(render()).toEqual(expected);
    expect(slots).toEqual([]);
    view.setActive(false);
  });

  it('does not pull a later harness switch across a reply into an earlier send', () => {
    const reply: RemoteMessage = { ...echo, id: 'reply', clientId: 'reply', role: 'assistant' };
    const boundary: RemoteMessage = { ...echo, id: 'switch', clientId: 'switch', role: 'agent_switch' };
    const first = appendOptimisticUserMessage([], [], queued, 's');
    const slots = appendOptimisticUserMessage(first, [echo, reply], { ...queued, clientId: 'next' }, 's');
    expect(projectOptimisticUserMessages([echo, reply, boundary], slots).map((message) => message.clientId))
      .toEqual(['sent', 'reply', 'switch', 'next']);
  });

  it.each([false, true])('keeps consecutive switches with their sends without a reply (next echoed=%s)', (echoed) => {
    const firstSwitch: RemoteMessage = { ...echo, id: 'switch-first', clientId: 'switch-first', role: 'agent_switch' };
    const secondSwitch: RemoteMessage = { ...firstSwitch, id: 'switch-next', clientId: 'switch-next' };
    const nextEcho: RemoteMessage = { ...echo, id: 'db-next', clientId: 'next' };
    const first = reconcileOptimisticUserMessages(appendOptimisticUserMessage([], [], queued, 's'), [echo], none, none);
    let slots = appendOptimisticUserMessage(first, [firstSwitch, echo], { ...queued, clientId: 'next' }, 's');
    const raw = [firstSwitch, echo, secondSwitch, ...(echoed ? [nextEcho] : [])];
    const expected = ['switch-first', 'sent', 'switch-next', 'next'];
    expect(projectOptimisticUserMessages(raw, slots).map((message) => message.clientId)).toEqual(expected);
    // A stale history page can still omit the first echo held by its reservation.
    expect(projectOptimisticUserMessages(raw.filter((message) => message.clientId !== 'sent'), slots)
      .map((message) => message.clientId)).toEqual(expected);
    const history = [firstSwitch, echo, secondSwitch, nextEcho];
    slots = reconcileOptimisticUserMessages(slots, history, none, new Set(expected));
    expect(slots).toEqual([]);
    expect(projectOptimisticUserMessages(history, slots).map((message) => message.clientId)).toEqual(expected);
  });

  it.each([false, true])('keeps a new send after history-only replies (echo=%s)', async (hasEcho) => {
    const previousUser = { ...echo, id: 'previous-user', clientId: 'previous-user', createdAt: '2026-09-16T23:59:00Z' };
    const previousReply: RemoteMessage = { ...echo, id: 'previous-reply', clientId: 'previous-reply', role: 'assistant', createdAt: '2026-09-16T23:59:10Z' };
    const freshReply: RemoteMessage = { ...previousReply, id: 'fresh-reply', clientId: 'fresh-reply', createdAt: '2026-09-16T23:59:20Z' };
    const nextReply: RemoteMessage = { ...previousReply, id: 'next-reply', clientId: 'next-reply', createdAt: '2026-09-17T00:00:10Z' };
    let history = [previousUser, previousReply];
    const view = new HistoryViewController<RemoteMessage>({
      page: async () => ({ version: 1, items: projectHistoryView(history, false), hasMore: false, nextCursor: null }),
      details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
      expanded: async () => undefined,
    });
    await view.refresh();
    const handoff = new HistoryViewHandoff<RemoteMessage>(() => true);
    const snapshot = view.getSnapshot();
    const displayed = handoff.reconcile(snapshot, []).messages;
    let slots = appendOptimisticUserMessage([], [], queued, 's', displayed);
    // A fresh push received before React renders must also precede the send.
    const freshSlots = appendOptimisticUserMessage([], [freshReply], queued, 's', displayed);
    expect(projectOptimisticUserMessages([...displayed, freshReply, nextReply], freshSlots)
      .map((row) => row.clientId)).toEqual(['previous-user', 'previous-reply', 'fresh-reply', 'sent', 'next-reply']);
    const raw = [...(hasEcho ? [echo] : []), nextReply];
    const render = () => {
      const snapshot = view.getSnapshot();
      slots = reconcileOptimisticUserMessages(slots, raw, new Set(['sent']), confirmedHistoryUserClientIds(snapshot, raw));
      const state = handoff.reconcile(snapshot, raw);
      return buildMobileHistoryRenderItems({ view, snapshot,
        messages: projectOptimisticUserMessages(state.messages, slots), pendingHandoff: state.pending,
        localUserClientIds: new Set(slots.map((entry) => entry.message.clientId)), streaming: false, sessionId: 's' })
        .map((item) => item.key);
    };
    const expected = [
      'message-previous-user', 'message-previous-reply', 'message-sent', 'message-next-reply',
    ];
    expect(render()).toEqual(expected);
    await view.refresh(); // A stale history refresh must retain the same position.
    expect(render()).toEqual(expected);
    history = [previousUser, previousReply, echo, nextReply];
    await view.refresh();
    expect(render()).toEqual(expected);
    expect(slots).toEqual([]);
    expect(appendOptimisticUserMessage([], [], queued, 's', history)).toEqual([]);
    view.setActive(false);
  });

  it.each([false, true])('keeps exactly one user row across a stale history page (initially ready=%s)', async (ready) => {
    let history: RemoteMessage[] = [];
    const view = new HistoryViewController<RemoteMessage>({
      page: async () => ({ version: 1, items: projectHistoryView(history, false), hasMore: false, nextCursor: null }),
      details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
      expanded: async () => undefined,
    });
    if (ready) await view.refresh();
    const handoff = new HistoryViewHandoff<RemoteMessage>((row) => row.agentMeta?.isStreaming === true);
    let slots = appendOptimisticUserMessage([], [], queued, 's');
    const render = (raw: RemoteMessage[], active = none) => {
      const snapshot = view.getSnapshot();
      const state = handoff.reconcile(snapshot, raw);
      slots = reconcileOptimisticUserMessages(slots, raw, active, confirmedHistoryUserClientIds(snapshot, raw));
      const messages = projectOptimisticUserMessages(state.messages, slots);
      return snapshot.ready
        ? buildMobileHistoryRenderItems({ view, snapshot, messages, pendingHandoff: state.pending,
          localUserClientIds: new Set(slots.map((entry) => entry.message.clientId)), streaming: false, sessionId: 's' })
        : buildMobileMessageRenderItems(messages, { preserveSourceOrder: true });
    };
    expect(render([], new Set(['sent'])).map((item) => item.key)).toEqual(['message-sent']);
    expect(render([echo]).map((item) => item.key)).toEqual(['message-sent']);
    await view.refresh(); // A page requested before enqueue finishes after the push.
    const stale = render([echo]);
    expect(stale.map((item) => item.key)).toEqual(['message-sent']);
    expect(JSON.stringify(stale)).toContain('authoritative hello');
    expect(slots).toHaveLength(1);
    history = [echo];
    await view.refresh();
    expect(render([echo]).map((item) => item.key)).toEqual(['message-sent']);
    expect(slots).toHaveLength(0);
    // After ownership transfers, clear/rewind must not resurrect a local copy.
    history = [];
    await view.refresh();
    expect(render([])).toEqual([]);
    view.setActive(false);
  });

  it.each([false, true])('covers drain before the queued frame commits (reserved=%s)', (reserved) => {
    let slots = reserved ? appendOptimisticUserMessage([], [], queued, 's') : [];
    // React never observed pendingQueue=[queued]. Completion still owns the bubble.
    const settling = settleEnqueueResult([], queued, true, queueInput());
    slots = [...reconcileOptimisticUserMessages(slots, [], new Set(settling.map((item) => item.clientId)), none)];
    const pending = buildPendingSendItems({ queue: [], settling, outbox: [], hiddenClientIds: none,
      sendingClientIds: none, editingClientId: null, steeringClientIds: none, presentationByClientId: new Map() });
    const render = (raw: RemoteMessage[]) => mergePendingSendItems(
      buildMobileMessageRenderItems(projectOptimisticUserMessages(raw, slots), { preserveSourceOrder: true }),
      pending, new Set(slots.filter((entry) => !raw.some((row) => row.clientId === entry.message.clientId))
        .map((entry) => entry.message.clientId)),
    );
    expect(render([]).map((item) => item.key)).toEqual(['message-sent']);
    expect(render([echo]).map((item) => item.key)).toEqual(['message-sent']);
    expect(settleEnqueueResult(settling, queued, true, queueInput())).toBe(settling);
    expect(settleEnqueueResult(settling, queued, false, queueInput())).toEqual([]);
  });

  it('does not claim a settling item while it remains queued', () => {
    const settling: QueuedRemoteMessage[] = [];
    expect(settleEnqueueResult(settling, queued, true, queueInput([queued]))).toBe(settling);
  });

  it('retains a busy send through raw-to-history switching without duplicating the echo', async () => {
    let history: RemoteMessage[] = [];
    const view = new HistoryViewController<RemoteMessage>({
      page: async () => ({ version: 1, items: projectHistoryView(history, false), hasMore: false, nextCursor: null }),
      details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
      expanded: async () => undefined,
    });
    const handoff = new HistoryViewHandoff<RemoteMessage>(() => false);
    let settling = settleEnqueueResult([], queued, true, queueInput());
    const render = () => {
      const snapshot = view.getSnapshot();
      const state = handoff.reconcile(snapshot, [echo]);
      const confirmed = confirmedHistoryUserClientIds(snapshot, [echo]);
      settling = settling.filter((item) => !confirmed.has(item.clientId));
      const pending = buildPendingSendItems({ queue: [], settling, outbox: [],
        hiddenClientIds: new Set(state.messages.map((row) => row.clientId)), sendingClientIds: none,
        editingClientId: null, steeringClientIds: none, presentationByClientId: new Map() });
      const rendered = snapshot.ready
        ? buildMobileHistoryRenderItems({ view, snapshot, messages: state.messages, streaming: false, sessionId: 's' })
        : buildMobileMessageRenderItems(state.messages);
      return mergePendingSendItems(rendered, pending, none);
    };
    expect(render().map((item) => item.key)).toEqual(['message-sent']);
    expect(settling).toHaveLength(1);
    await view.refresh();
    expect(render().map((item) => item.key)).toEqual(['message-sent']);
    history = [echo];
    await view.refresh();
    expect(render().map((item) => item.key)).toEqual(['message-sent']);
    expect(settling).toEqual([]);
    view.setActive(false);
  });

  it('drops a reservation when the raw echo is deleted before history takes over', () => {
    let slots = appendOptimisticUserMessage([], [], queued, 's');
    slots = reconcileOptimisticUserMessages(slots, [echo], none, none);
    expect(slots[0].message).toBe(echo);
    expect(reconcileOptimisticUserMessages(slots, [], none, none)).toEqual([]);
  });

  it.each(['CHANNEL_NOT_ALLOWED', 'UNSUPPORTED_CAPABILITY', 'NETWORK_ERROR'])('uses raw ordering only for permanent history unavailability: %s', async (error) => {
    const view = new HistoryViewController<RemoteMessage>({
      page: async () => { throw new Error(error); },
      details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
      expanded: async () => undefined,
    });
    await view.refresh();
    const raw = [{ ...echo, clientId: 'other-controller', id: 'other-controller' }, echo];
    const confirmed = confirmedHistoryUserClientIds(view.getSnapshot(), raw);
    const slots = reconcileOptimisticUserMessages(appendOptimisticUserMessage([], [], queued, 's'), raw, none, confirmed);
    if (error === 'NETWORK_ERROR') {
      expect(confirmed.size).toBe(0);
      expect(slots).toHaveLength(1);
    } else {
      expect(slots).toEqual([]);
      expect(projectOptimisticUserMessages(raw, slots)).toBe(raw);
      expect(confirmed.has('sent')).toBe(true);
    }
    view.setActive(false);
  });

  it('does not revive a remotely deleted middle item after enqueue acceptance', () => {
    const predecessor = { ...queued, clientId: 'before' };
    expect(settleEnqueueResult([], queued, true, queueInput([predecessor], {
      previous: [predecessor, queued],
    }))).toEqual([]);
    expect(settleEnqueueResult([], queued, true, queueInput([], {
      previous: [predecessor, queued],
    }))).toEqual([queued]);
    expect(settleEnqueueResult([], queued, true, queueInput([predecessor], {
      previous: [predecessor, queued], currentSteeringClientIds: new Set(['sent']),
    }))).toEqual([queued]);
  });

  it.each(['hiddenClientIds', 'locallyRemovedClientIds'] as const)('does not settle an already retired item (%s)', (field) => {
    expect(settleEnqueueResult([], queued, true, queueInput([], { [field]: new Set(['sent']) }))).toEqual([]);
  });

  it('只有后面已出现消息的已确认用户行才算 turn 跑过', async () => {
    const previousReply: RemoteMessage = { ...echo, id: 'previous-reply', clientId: 'previous-reply', role: 'assistant', createdAt: '2026-09-16T23:59:10Z' };
    const reply: RemoteMessage = { ...previousReply, id: 'reply', clientId: 'reply', createdAt: '2026-09-17T00:00:10Z' };
    let history: RemoteMessage[] = [previousReply, echo];
    const view = new HistoryViewController<RemoteMessage>({
      page: async () => ({ version: 1, items: projectHistoryView(history, false), hasMore: false, nextCursor: null }),
      details: async () => ({ version: 1, messages: [], hasMore: false, nextCursor: null }),
      expanded: async () => undefined,
    });
    await view.refresh();
    // 权威历史已落库用户行、实时推送还停在上一条回复:派发前钩子期间,不算跑过。
    expect(repliedHistoryUserClientIds(view.getSnapshot(), [previousReply])).toEqual(new Set());
    // 实时推送先到回复(快速 turn),权威历史还没刷新:算跑过。
    expect(repliedHistoryUserClientIds(view.getSnapshot(), [echo, reply])).toEqual(new Set(['sent']));
    history = [previousReply, echo, reply];
    await view.refresh();
    expect(repliedHistoryUserClientIds(view.getSnapshot(), [previousReply])).toEqual(new Set(['sent']));
  });
});