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。

21.9 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest';
import { HistoryViewController, historyAfter, projectHistoryView, type HistoryWorkSummary } from '@cindy/maker-shared/message-window';
import { buildMobileHistoryRenderItems, buildMobileSessionRenderWindow } from '../session/mobileHistoryRender';
import { buildMobileMessageRenderItems, type MobileMessageRenderItem } from '../session/messageRenderModel';
import type { RemoteMessage } from '../session/types';
import { reconcileMobileMessageRenderItems } from '../session/messageRenderReconcile';
import { buildMobileStreamingRenderWindow } from '../session/messageRenderStreamingCache';
import { CONTINUE_AFTER_ERROR_PROMPT } from '@cindy/maker-shared/synthetic-trigger';
import { companionConversationItems } from '../session/companionConversationPresentation';

function row(index: number, role: RemoteMessage['role'], content: unknown, toolUseId: string | null = null): RemoteMessage {
  return { id: `id-${index}`, clientId: `client-${index}`, sessionId: 'session', role, content, toolUseId,
    createdAt: new Date(1_700_000_000_000 + index * 1000).toISOString(), agentMeta: null };
}
const call = (index: number, name = 'Read', id = `tool-${index}`) => row(index, 'tool_use', { toolUseId: id, toolName: name, input: {} }, id);
const thought = (index: number) => row(index, 'thinking', { text: 'reasoning', durationMs: 500 });
const outline = (items: MobileMessageRenderItem[]): unknown[] => items.map((item) => item.type === 'work_group'
  ? { key: item.key, type: item.type, children: outline(item.children.filter((child) => child.type === 'work_group' || child.type === 'message')) }
  : { key: item.key, type: item.type });

function harness(rows: RemoteMessage[], streaming = false, lazyDetails = false) {
  const details = vi.fn(async (summary: HistoryWorkSummary, after?: string) => {
    const start = rows.findIndex((item) => item.id === (after ?? summary.firstMessageId)) + (after ? 1 : 0);
    const end = rows.findIndex((item) => item.id === summary.lastMessageId) + 1;
    const messages = rows.slice(start, Math.min(start + 2, end));
    return { version: 1 as const, messages, hasMore: start + 2 < end, nextCursor: messages.at(-1)?.id ?? null };
  });
  const expanded = vi.fn(async (_refs: readonly HistoryWorkSummary[]) => undefined);
  const view = new HistoryViewController<RemoteMessage>({
    page: async () => ({ version: 1, items: projectHistoryView(rows, streaming, lazyDetails), hasMore: false, nextCursor: null }),
    details, expanded,
  });
  const render = () => buildMobileHistoryRenderItems({ view, snapshot: view.getSnapshot(), messages: [], streaming, sessionId: 'session' });
  return { view, details, expanded, render };
}

describe('remote history preserves original folding', () => {
  // #7081: the host outline must agree with raw grouping when progress directly precedes the final.
  it.each([false, true])('folds adjacent companion commentary after history takeover (lazy=%s)', async (lazy) => {
    const rows = [row(0, 'user', 'Work'),
      { ...row(1, 'assistant', 'Checking'), agentMeta: { assistantPhase: 'commentary' } },
      { ...row(2, 'assistant', 'Done'), agentMeta: { assistantPhase: 'final_answer', turnCompleted: true } }];
    const { view, render } = harness(rows, false, lazy);
    await view.refresh();
    const loaded = companionConversationItems(render());
    expect(loaded.filter(item => item.type === 'message').map(item => item.message.body)).toEqual(['Work', 'Done']);
    expect(outline(loaded)).toEqual(outline(companionConversationItems(buildMobileMessageRenderItems(rows))));
    expect(JSON.stringify(loaded.find(item => item.type === 'work_group'))).toContain('Checking');
    view.setActive(false);
  });
  // Unit: a child inherits the transcript for the model but only its new turns
  // belong on screen. Exercise real rendering with both eager and lazy work.
  it.each([false, true])('hides inherited work and messages in a side chat (lazy=%s)', async (lazy) => {
    const rows = [row(0, 'user', 'parent prompt'), thought(1), row(2, 'assistant', 'parent answer'),
      row(3, 'user', 'child question'), thought(4), row(5, 'assistant', 'child answer')];
    const { view } = harness(rows, false, lazy);
    await view.refresh();
    const result = buildMobileHistoryRenderItems({ view,
      snapshot: historyAfter(view.getSnapshot(), Date.parse(rows[3].createdAt))!,
      messages: [], streaming: false, sessionId: 'session', sessionSource: 'side-chat' });
    expect(result.map(item => item.key)).toEqual(['message-client-3', 'work-client-4', 'message-client-5']);
    expect(view.getSnapshot().items.length).toBeGreaterThan(3);
    view.setActive(false);
  });
  // Regression: mobile's companion projection used to flatten away deferred
  // work after history takeover. Verify the production controller's expansion
  // still reads the original thinking/tool rows and never hides a provider final.
  it.each(['final_answer', 'commentary'])('preserves companion %s and lazy work through history takeover and expansion', async (assistantPhase) => {
    const rows = [row(0, 'user', 'Work'),
      { ...row(1, 'assistant', 'First reply'), agentMeta: { assistantPhase } },
      thought(2), call(3), row(4, 'tool_result', 'Read result', 'tool-3')];
    const { view, render, details } = harness(rows, true, true);
    const raw = companionConversationItems(buildMobileMessageRenderItems(rows, { isSessionStreaming: true }));
    await view.refresh();
    const loaded = companionConversationItems(render());
    expect(loaded.map(item => item.key)).toEqual(raw.map(item => item.key));
    const work = loaded.find(item => item.type === 'work_group');
    if (work?.type !== 'work_group') throw new Error('Missing companion work');
    expect(details).not.toHaveBeenCalled();
    work.deferred!.setVisible!(true, false);
    await vi.waitFor(() => expect([...view.getSnapshot().details.values()].some(state => state.complete)).toBe(true));
    expect(JSON.stringify(companionConversationItems(render()))).toContain('reasoning');
    expect(companionConversationItems(render()).filter(item => item.type === 'message').map(item => item.message.body))
      .toEqual(['Work', 'First reply']);
    view.setActive(false);
  });
  it.each([false, true])('keeps the earlier answer when recovery follows an unloaded gap (streaming=%s)', async (streaming) => {
    const rows = [row(0, 'user', 'Work'), thought(1), row(2, 'assistant', 'Earlier answer'),
      row(4000, 'user', JSON.stringify({ text: CONTINUE_AFTER_ERROR_PROMPT })),
      row(4001, 'assistant', 'Continuing')];
    const { view, render } = harness(rows, streaming);
    await view.refresh();
    expect(render().map(item => item.key)).toEqual([
      'message-client-0', 'work-client-1', 'message-client-2', 'message-client-4001',
    ]);
    expect(outline(render())).toEqual(outline(buildMobileMessageRenderItems(rows, { isSessionStreaming: streaming })));
    view.setActive(false);
  });

  it.each([false, true])('keeps steering visible while recovering work on both sides (streaming=%s)', async (streaming) => {
    const rows = [row(0, 'user', 'Work'), row(1, 'assistant', 'Before steer'), thought(2),
      { ...row(3, 'user', 'Check this too'), agentMeta: { delivery: 'steer' } },
      row(4, 'assistant', 'After steer'), thought(5),
      row(6, 'user', JSON.stringify({ text: CONTINUE_AFTER_ERROR_PROMPT })),
      row(7, 'assistant', 'Continuing')];
    const { view, render } = harness(rows, streaming);
    await view.refresh();
    expect(render().map(item => item.key)).toEqual([
      'message-client-0', 'work-summary-client-2', 'message-client-3',
      'work-summary-client-5', 'message-client-7',
    ]);
    expect(outline(render())).toEqual(outline(buildMobileMessageRenderItems(rows, { isSessionStreaming: streaming })));
    view.setActive(false);
  });

  it.each([CONTINUE_AFTER_ERROR_PROMPT, { text: CONTINUE_AFTER_ERROR_PROMPT },
    JSON.stringify({ text: CONTINUE_AFTER_ERROR_PROMPT, images: [], files: [] }),
  ])('keeps recovered work folded after reopening and restores details on expansion: %j', async (content) => {
    const rows = [row(0, 'user', 'Work'), row(1, 'assistant', 'Checking'), thought(2),
      row(3, 'error', { message: 'Usage limit reached' }),
      row(4, 'user', content),
      row(5, 'assistant', 'Resuming'), thought(6),
      { ...row(7, 'assistant', 'Done'), agentMeta: { turnCompleted: true } }];
    const { view, render } = harness(rows);
    await view.refresh();
    const output = render();
    expect(output.map((item) => item.key)).toEqual([
      'message-client-0', 'work-summary-client-2', 'message-client-3',
      'work-summary-client-6', 'message-client-7',
    ]);
    const work = output[1];
    if (work.type !== 'work_group') throw new Error('Missing recovered work');
    expect(work.children[0]).toMatchObject({ type: 'message', message: { body: 'Checking' } });
    const actions = work.children.find((item) => item.type === 'work_group');
    if (actions?.type !== 'work_group') throw new Error('Missing action details');
    actions.deferred!.setVisible!(true, false);
    await vi.waitFor(() => expect([...view.getSnapshot().details.values()].some((state) => state.complete)).toBe(true));
    expect(outline(render())).toEqual(outline(buildMobileMessageRenderItems(rows)));
    view.setActive(false);
  });

  it.each([0, 2_000_000_000_000])('keeps a local send before an early reply with phone time %s', async (phoneTime) => {
    const rows = [row(0, 'user', 'Earlier'), row(1, 'assistant', 'Done')];
    const { view } = harness(rows);
    await view.refresh();
    const sent = { ...row(2, 'user', 'Continue'), createdAt: new Date(phoneTime).toISOString() };
    const reply = { ...row(3, 'assistant', 'Reply'), agentMeta: { isStreaming: true } };
    const render = (user: RemoteMessage) => buildMobileHistoryRenderItems({
      view, snapshot: view.getSnapshot(), messages: [...rows.slice(0, 2), user, reply],
      streaming: true, sessionId: 'session', localUserClientIds: new Set([sent.clientId]),
    });
    const expected = ['message-client-0', 'message-client-1', 'message-client-2', 'message-client-3'];
    expect(render(sent).map((item) => item.key)).toEqual(expected);
    // Durable push before the history refresh must replace the local body, not
    // drop the row or append it after its response.
    const echo = row(2, 'user', 'Confirmed');
    expect(render(echo).map((item) => item.key)).toEqual(expected);
    rows.push(echo, row(3, 'assistant', 'Reply'));
    await view.refresh();
    expect(render(echo).map((item) => item.key)).toEqual(expected);
    view.setActive(false);
  });

  it('clips retained detail bodies when a visible media tool splits the old range', async () => {
    const rows = [row(0, 'user', 'Work'), call(1), row(2, 'tool_result', 'ok', 'tool-1'), thought(3),
      call(4), row(5, 'tool_result', 'pending', 'tool-4'), thought(6), call(7), row(8, 'tool_result', 'ok', 'tool-7'), row(9, 'assistant', 'Done')];
    const { view, render } = harness(rows);
    await view.refresh();
    const work = render()[1];
    if (work.type !== 'work_group') throw new Error('Missing work');
    work.deferred!.setVisible!(true, false);
    await vi.waitFor(() => expect([...view.getSnapshot().details.values()].every((state) => state.complete)).toBe(true));
    const current = rows.map((item) => item.id === 'id-5' ? { ...item, content: JSON.stringify({ xdt_image_url: 'cindy-media://blobs/image.png' }) } : item);
    const snapshot = { ...view.getSnapshot(), items: projectHistoryView(current, false) };
    const output = buildMobileHistoryRenderItems({ view, snapshot, messages: [], streaming: false, sessionId: 'session' });
    const tools = (items: MobileMessageRenderItem[]): string[] => items.flatMap((item): string[] => item.type === 'work_group' ? tools(item.children)
      : item.type === 'tool_group' || item.type === 'tool_media' ? item.tools.map((tool) => tool.source.clientId) : []);
    expect(tools(output)).toContain('client-1');
    expect(tools(output).filter((id) => id === 'client-1')).toHaveLength(1);
    expect(tools(output)).not.toContain('client-7');
    expect(outline(output)).toEqual(outline(buildMobileMessageRenderItems(current)));
    view.setActive(false);
  });

  it('uses current visible source rows when an old detail range becomes a media result', async () => {
    const rows = [row(0, 'user', 'Work'), thought(1), call(2), row(3, 'tool_result', 'pending', 'tool-2'), row(4, 'assistant', 'Done')];
    const { view, render } = harness(rows);
    await view.refresh();
    const work = render()[1];
    if (work.type !== 'work_group') throw new Error('Missing work');
    work.deferred!.setVisible!(true, false);
    await vi.waitFor(() => expect([...view.getSnapshot().details.values()].every((state) => state.complete)).toBe(true));
    const current = rows.map((item) => item.id === 'id-3' ? { ...item, content: JSON.stringify({ xdt_image_url: 'cindy-media://blobs/image.png' }) } : item);
    const snapshot = { ...view.getSnapshot(), items: projectHistoryView(current, false) };
    const output = buildMobileHistoryRenderItems({ view, snapshot, messages: [], streaming: false, sessionId: 'session' });
    expect(outline(output)).toEqual(outline(buildMobileMessageRenderItems(current)));
    view.setActive(false);
  });

  it('keeps true child-agent ownership and untagged paired results intact', async () => {
    const rows = [row(0, 'user', 'Work'), call(1, 'Agent', 'agent'),
      { ...call(2, 'Read', 'child-tool'), agentMeta: { parentUuid: 'agent' } },
      row(3, 'tool_result', 'child result', 'child-tool'),
      { ...row(4, 'assistant', 'child answer'), agentMeta: { parentUuid: 'agent' } },
      row(5, 'tool_result', 'agent done', 'agent'), row(6, 'assistant', 'Done')];
    const { view, render } = harness(rows);
    await view.refresh();
    expect(render().find((item) => item.type === 'subagent_group'))
      .toEqual(buildMobileMessageRenderItems(rows).find((item) => item.type === 'subagent_group'));
    view.setActive(false);
  });

  it.each([
    ['media inside a contiguous tool segment', [row(0, 'user', 'Work'), call(1), row(2, 'tool_result', 'ok', 'tool-1'),
      call(3), row(4, 'tool_result', JSON.stringify({ xdt_image_url: 'cindy-media://blobs/image.png' }), 'tool-3'),
      call(5), row(6, 'tool_result', 'ok', 'tool-5'), row(7, 'assistant', 'Done')]],
    ['progress and source-code markers', [row(0, 'user', 'Work'), row(1, 'assistant', 'Checking'), call(2),
      row(3, 'tool_result', 'source contains <tool_use_error> and cindy-media:', 'tool-2'), thought(4),
      row(5, 'assistant', 'Next'), call(6), row(7, 'tool_result', 'ok', 'tool-6'), row(8, 'assistant', 'Done')]],
    ['pure actions', [row(0, 'user', 'Work'), thought(1), call(2), row(3, 'tool_result', 'ok', 'tool-2'), row(4, 'assistant', 'Done')]],
    ['omitted thinking', [row(0, 'user', 'Work'), row(1, 'thinking', { text: '', durationMs: 0 }), row(2, 'assistant', 'Done')]],
    ['omitted thinking before action', [row(0, 'user', 'Work'), row(1, 'thinking', { text: '', durationMs: 0 }), call(2), row(3, 'assistant', 'Done')]],
    ['late result after progress', [row(0, 'user', 'Work'), call(1), row(2, 'assistant', 'Checking'), row(3, 'tool_result', 'ok', 'tool-1'), row(4, 'assistant', 'Done')]],
    ['Workflow and delivery prose', [row(0, 'user', 'Work'), thought(1), call(2, 'Workflow'), row(3, 'tool_result', 'done', 'tool-2'),
      row(4, 'assistant', '# Deliverable\nKeep this visible'), thought(5), row(6, 'assistant', 'Done')]],
    ['explicit user boundary', [row(0, 'user', 'First'), thought(1), row(2, 'assistant', 'Done'), row(3, 'user', 'Second'), thought(4), row(5, 'assistant', 'Done')]],
  ] as const)('keeps the same group identities and nesting: %s', async (_name, fixture) => {
    const rows = [...fixture];
    for (const lazyDetails of [false, true]) {
    const { view, render, details } = harness(rows, false, lazyDetails);
    await view.refresh();
    expect(outline(render())).toEqual(outline(buildMobileMessageRenderItems(rows, { isSessionStreaming: false })));
    expect(details).not.toHaveBeenCalled();
    view.setActive(false);
    }
  });

  it('opens only the chosen inner group, reads all pages, and retains the outer hierarchy', async () => {
    const rows = [row(0, 'user', 'Work'), row(1, 'assistant', 'Checking'), thought(2), call(3),
      row(4, 'tool_result', 'ok', 'tool-3'), thought(5), row(6, 'assistant', 'Next'), thought(7), row(8, 'assistant', 'Done')];
    const { view, render, details } = harness(rows);
    await view.refresh();
    const outer = render()[1];
    expect(outer.type).toBe('work_group');
    if (outer.type !== 'work_group') throw new Error('Missing outer group');
    expect(outer.deferred).toBeUndefined();
    const inner = outer.children.find((item) => item.type === 'work_group');
    if (inner?.type !== 'work_group') throw new Error('Missing inner group');
    inner.deferred!.setVisible!(true, false);
    await vi.waitFor(() => expect([...view.getSnapshot().details.values()].every((state) => state.complete)).toBe(true));
    expect(details).toHaveBeenCalledTimes(2);
    expect(view.getSnapshot().expanded.size).toBe(1);
    expect(outline(render())).toEqual(outline(buildMobileMessageRenderItems(rows, { isSessionStreaming: false })));
    const loaded = render()[1];
    if (loaded.type !== 'work_group') throw new Error('Missing loaded group');
    const loadedInner = loaded.children.find((item) => item.type === 'work_group');
    if (loadedInner?.type !== 'work_group') throw new Error('Missing loaded inner group');
    expect(loadedInner.children.length).toBeGreaterThan(0);
    loadedInner.deferred!.setVisible!(false, false);
    await view.refresh();
    expect(details).toHaveBeenCalledTimes(2);
    expect(view.getSnapshot().expanded.size).toBe(0);
    view.setActive(false);
  });

  it('uses the same bounded detail reader for desktop preview without opening the full range', async () => {
    const rows = [row(0, 'user', 'Work'), ...Array.from({ length: 12 }, (_, index) => thought(index + 1))];
    const { view, render, details } = harness(rows, true);
    await view.refresh();
    const group = render()[1];
    if (group.type !== 'work_group') throw new Error('Missing active group');
    group.deferred!.setVisible!(false, false);
    expect(details).not.toHaveBeenCalled();
    group.deferred!.setVisible!(false, true);
    await vi.waitFor(() => expect(details).toHaveBeenCalledTimes(3));
    const state = [...view.getSnapshot().details.values()][0];
    expect(state.messages.map((item) => item.id)).toEqual(rows.slice(-5).map((item) => item.id));
    expect([...view.getSnapshot().expanded]).toEqual([`preview-work-client-1`]);
    group.deferred!.setVisible!(false, false);
    view.setActive(false);
  });
});


it.each([true, false])('loads a folded subagent only on expansion while retaining the visible turn (running=%s)', async (streaming) => {
  const agent = { ...call(1, 'Agent', 'a'), content: { toolName: 'Agent', toolUseId: 'a', input: { description: 'Inspect' } } };
  const children = Array.from({ length: 40 }, (_, i) => ({ ...thought(i + 2), agentMeta: { parentUuid: 'a' } }));
  const rows = [row(0, 'user', 'Investigate'), agent, ...children, row(42, 'assistant', 'Visible response')];
  const { view, details, render } = harness(rows, streaming, true);
  await view.refresh();
  expect(details).not.toHaveBeenCalled();
  const first = render();
  expect(first.some((item) => item.type === 'message' && item.message.body === 'Visible response')).toBe(true);
  const card = first.find((item) => item.type === 'subagent_group');
  if (card?.type !== 'subagent_group') throw new Error('missing card');
  expect(card.childItems).toEqual([]);
  expect(card.status).toBe(streaming ? 'running' : 'completed');
  expect(card.deferred).toBeDefined();
  card.deferred!.toggle();
  await vi.waitFor(() => expect(view.getSnapshot().details.get(card.deferred!.key!)?.complete).toBe(true));
  expect(details).toHaveBeenCalledTimes(20);
  const expanded = render().find((item) => item.type === 'subagent_group');
  expect(expanded?.type === 'subagent_group' && expanded.childItems.length).toBeGreaterThan(0);
  expect(expanded?.type === 'subagent_group' && expanded.deferred?.loading).toBe(false);
  if (expanded?.type === 'subagent_group' && expanded.deferred) {
    const pending = { ...expanded, deferred: { ...expanded.deferred, loading: true } };
    const reconciled = reconcileMobileMessageRenderItems([pending], [expanded]);
    expect(reconciled[0]).toBe(expanded);
  }
  view.setActive(false);
});

// Unit: existing history rendering tests bypassed the screen's source selection.
// Minimal regression: distinct cached/raw answers with a previously warmed prefix.
it.each([false, true])('selects visible rows without reading unused raw bodies (ready=%s)', async ready => {
  const { view } = harness([row(10, 'assistant', 'Cached answer')]);
  if (ready) await view.refresh();
  const prefixCache = { current: null as ReturnType<typeof buildMobileStreamingRenderWindow>['prefix'] };
  const warmed = [row(0, 'user', 'First'), row(1, 'assistant', 'Done'), row(2, 'user', 'Next'),
    { ...row(3, 'assistant', 'Streaming'), agentMeta: { isStreaming: true } }];
  buildMobileStreamingRenderWindow({ cacheKey: 'en', messages: warmed,
    options: { sessionId: 'session', isSessionStreaming: true }, prefixCache });
  expect(prefixCache.current).not.toBeNull();
  const readRawBody = vi.fn(() => 'Raw answer');
  const raw = row(4, 'assistant', '');
  Object.defineProperty(raw, 'content', { get: readRawBody });
  const result = buildMobileSessionRenderWindow({
    raw: { cacheKey: 'en', messages: [raw], options: { sessionId: 'session' }, prefixCache },
    history: { view, snapshot: view.getSnapshot(), messages: [], streaming: false, sessionId: 'session' },
  });
  expect(result.items).toMatchObject([{ type: 'message', message: { body: ready ? 'Cached answer' : 'Raw answer' } }]);
  expect(result.diffCount).toBe(0);
  expect(result.prefix).toBeNull();
  expect(result.stablePrefixItemCount).toBe(0);
  if (ready) {
    expect(readRawBody).not.toHaveBeenCalled();
    expect(prefixCache.current).toBeNull();
  } else {
    expect(readRawBody).toHaveBeenCalled();
  }
  view.setActive(false);
});