Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
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);
});