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。

13.2 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import {
  buildMessageToolResultPairing,
  messageContentToPreview,
  messageNormalizeKey,
  parseMessageToolUse,
  sortMessagesByCreatedAt,
} from '../messageNormalize.js';

interface FixtureMessage {
  id: string;
  clientId: string;
  role: string;
  content: unknown;
  toolUseId: string | null;
  createdAt: string;
}

function message(patch: Partial<FixtureMessage> & Pick<FixtureMessage, 'id' | 'role' | 'content'>): FixtureMessage {
  return {
    clientId: patch.id,
    toolUseId: null,
    createdAt: '2026-01-01T00:00:00.000Z',
    ...patch,
  };
}

describe('message normalize shared model', () => {
  it('unwraps Pi MCP calls without changing their identity or nested arguments', () => {
    const input = { ghost_id: 'demo', tool: 'show', args: { value: 1 } };
    const raw = message({ id: 'pi', role: 'tool_use', toolUseId: 'call-pi', content: {
      toolName: 'cindy_mcp_call_tool', input: { server: 'cindy', tool: 'ghost_call', args: input },
    } });
    const tool = parseMessageToolUse(raw);
    expect(tool).toEqual({ toolUseId: 'call-pi', toolName: 'mcp:cindy:ghost_call', input });
    expect(tool.input).toBe(input);
    expect(parseMessageToolUse({ ...raw, content: tool })).toEqual(tool);
    expect((raw.content as { toolName: string }).toolName).toBe('cindy_mcp_call_tool');
    expect(parseMessageToolUse({ role: 'tool_use', content: {
      toolName: 'cindy_mcp_call_tool', input: { server: 'custom', tool: 'status' },
    } })).toMatchObject({ toolName: 'mcp:custom:status', input: {} });
  });

  it.each([null, [], {}, { server: 'cindy' }, { server: 'cindy', tool: 'ghost_call', args: [] }])(
    'preserves malformed gateway inputs for diagnostics: %j', (input) => {
      expect(parseMessageToolUse({ role: 'tool_use', content: { toolName: 'cindy_mcp_call_tool', input } }))
        .toMatchObject({ toolName: 'cindy_mcp_call_tool', input });
    },
  );

  it('builds text previews from desktop content shapes', () => {
    expect(messageContentToPreview('plain')).toBe('plain');
    expect(messageContentToPreview([
      { type: 'text', text: 'answer' },
      { type: 'thinking', thinking: 'inspect' },
      { text: 'tail' },
    ])).toBe('answer\ninspect\ntail');
    expect(messageContentToPreview({ content: 'from content' })).toBe('from content');
    expect(messageContentToPreview({ value: 1 })).toBe(JSON.stringify({ value: 1 }, null, 2));
    expect(messageContentToPreview(null)).toBe('');
  });

  it('sorts raw messages by createdAt while preserving equal-time input order', () => {
    const sameTimeA = message({ id: 'a', role: 'assistant', content: 'a', createdAt: '2026-01-01T00:00:02.000Z' });
    const older = message({ id: 'older', role: 'user', content: 'q', createdAt: '2026-01-01T00:00:01.000Z' });
    const sameTimeB = message({ id: 'b', role: 'assistant', content: 'b', createdAt: '2026-01-01T00:00:02.000Z' });

    expect(sortMessagesByCreatedAt([sameTimeA, older, sameTimeB]).map((item) => item.id)).toEqual([
      'older',
      'a',
      'b',
    ]);
  });

  it('reads stable keys and tool_use payloads from desktop-like messages', () => {
    const tool = message({
      id: '',
      clientId: 'client-tool',
      role: 'tool_use',
      toolUseId: null,
      content: { toolUseId: 'tu_1', toolName: 'Read', input: { file_path: '/repo/app.ts' } },
    });

    expect(messageNormalizeKey(tool)).toBe('client-tool');
    expect(parseMessageToolUse(tool)).toEqual({
      toolUseId: 'tu_1',
      toolName: 'Read',
      input: { file_path: '/repo/app.ts' },
    });
  });

  it('pairs tool_result by toolUseId and hides standalone results from render adapters', () => {
    const sorted = sortMessagesByCreatedAt([
      message({
        id: 'tool',
        role: 'tool_use',
        content: { toolUseId: 'tu_1', toolName: 'Read', input: { file_path: '/repo/app.ts' } },
      }),
      message({
        id: 'result',
        role: 'tool_result',
        toolUseId: 'tu_1',
        content: 'file contents',
      }),
      message({
        id: 'orphan',
        role: 'tool_result',
        content: 'orphan',
      }),
    ]);

    const pairing = buildMessageToolResultPairing(sorted);
    const tool = parseMessageToolUse(sorted[0]);

    expect(pairing.resultContentFor(sorted[0], tool)).toBe('file contents');
    expect(pairing.resultByToolUseId.get('tu_1')).toBe('file contents');
    expect(pairing.resultByToolUseId.has('missing')).toBe(false);
  });

  it('uses adjacent legacy tool_result when toolUseId is missing', () => {
    const sorted = sortMessagesByCreatedAt([
      message({
        id: 'legacy-tool',
        role: 'tool_use',
        content: { toolName: 'Read', input: { file_path: '/repo/legacy.ts' } },
        createdAt: '2026-01-01T00:00:01.000Z',
      }),
      message({
        id: 'legacy-result',
        role: 'tool_result',
        content: 'legacy file contents',
        createdAt: '2026-01-01T00:00:02.000Z',
      }),
    ]);

    const pairing = buildMessageToolResultPairing(sorted);
    expect(pairing.resultContentFor(sorted[0], parseMessageToolUse(sorted[0]))).toBe('legacy file contents');
  });

  it('结束时刻只认 toolUseId 精确配对,不吃邻接兜底', () => {
    // 回归(#1210 review):邻接兜底按"紧邻的下一条 tool_result"猜归属,在稀疏窗口里会猜错 ——
    // 孤岛窗口的旧段末尾 tool_use 恰好与新段开头某条不相关的 tool_result 相邻时,若结束时刻也
    // 吃这份兜底,旧工具的 settledAt 会变成几小时后那条结果的时刻,渲染层 tool_group 的结束锚点
    // 被推过去,真实的窗口空洞不再触发切组 —— 兜底正好在最需要它的场景失效。
    // 内容与 settled 状态照旧走邻接(猜错最坏是显示串了,live 中按 id 到达即自愈);时刻不猜。
    const sorted = sortMessagesByCreatedAt([
      message({
        id: 'island-tail-tool',
        role: 'tool_use',
        content: { toolName: 'Read', input: { file_path: '/repo/a.ts' } },
        createdAt: '2026-07-31T06:00:00.000Z',
      }),
      message({
        id: 'next-island-result',
        role: 'tool_result',
        content: 'unrelated result from two hours later',
        createdAt: '2026-07-31T08:20:00.000Z',
      }),
    ]);

    const pairing = buildMessageToolResultPairing(sorted);
    const tool = parseMessageToolUse(sorted[0]);
    expect(pairing.resultContentFor(sorted[0], tool)).toBe('unrelated result from two hours later');
    expect(pairing.hasResultFor(sorted[0], tool)).toBe(true);
    expect(pairing.resultCreatedAtFor(sorted[0], tool)).toBeUndefined();
  });

  it('结束时刻按 toolUseId 命中时取最晚一条结果', () => {
    const sorted = sortMessagesByCreatedAt([
      message({
        id: 'paired-tool',
        role: 'tool_use',
        toolUseId: 'tu_end',
        content: { toolUseId: 'tu_end', toolName: 'Bash', input: { command: 'sleep' } },
        createdAt: '2026-07-31T06:00:00.000Z',
      }),
      message({
        id: 'paired-result-early',
        role: 'tool_result',
        toolUseId: 'tu_end',
        content: 'partial',
        createdAt: '2026-07-31T06:10:00.000Z',
      }),
      message({
        id: 'paired-result-late',
        role: 'tool_result',
        toolUseId: 'tu_end',
        content: 'done',
        createdAt: '2026-07-31T06:20:00.000Z',
      }),
    ]);

    const pairing = buildMessageToolResultPairing(sorted);
    expect(pairing.resultCreatedAtFor(sorted[0], parseMessageToolUse(sorted[0])))
      .toBe('2026-07-31T06:20:00.000Z');
  });

  it('suppresses empty Orca communication results but keeps user-facing details', () => {
    const sorted = sortMessagesByCreatedAt([
      message({
        id: 'orca-empty-tool',
        role: 'tool_use',
        content: { toolUseId: 'orca-empty', toolName: 'mcp__orca_worker_bridge__send_to_lead', input: {} },
      }),
      message({
        id: 'orca-empty-result',
        role: 'tool_result',
        toolUseId: 'orca-empty',
        content: JSON.stringify({ ok: true }),
      }),
      message({
        id: 'orca-detail-tool',
        role: 'tool_use',
        content: { toolUseId: 'orca-detail', toolName: 'read_lead', input: {} },
      }),
      message({
        id: 'orca-detail-result',
        role: 'tool_result',
        toolUseId: 'orca-detail',
        content: JSON.stringify({ ok: true, message: 'Lead replied: continue' }),
      }),
    ]);

    const pairing = buildMessageToolResultPairing(sorted);

    expect(pairing.resultContentFor(sorted[0], parseMessageToolUse(sorted[0]))).toBeUndefined();
    expect(pairing.resultContentFor(sorted[2], parseMessageToolUse(sorted[2]))).toBe(
      JSON.stringify({ ok: true, message: 'Lead replied: continue' }),
    );
    // 内容被隐藏 ≠ 未完成:状态判定(hasResultFor)必须计入被隐藏的 orca 空结果,
    // 否则这类工具行会永久显示进行中(桌面 #454 settledIds 的同款回归)。
    expect(pairing.hasResultFor(sorted[0], parseMessageToolUse(sorted[0]))).toBe(true);
  });

  it('reports settled state via hasResultFor for id, adjacency and pending tools', () => {
    const sorted = sortMessagesByCreatedAt([
      message({
        id: 'tool-done',
        role: 'tool_use',
        content: { toolUseId: 'tu_done', toolName: 'Read', input: { file_path: '/repo/a.ts' } },
        createdAt: '2026-01-01T00:00:01.000Z',
      }),
      message({
        id: 'result-done',
        role: 'tool_result',
        toolUseId: 'tu_done',
        content: 'contents',
        createdAt: '2026-01-01T00:00:02.000Z',
      }),
      message({
        id: 'legacy-tool',
        role: 'tool_use',
        content: { toolName: 'Read', input: { file_path: '/repo/b.ts' } },
        createdAt: '2026-01-01T00:00:03.000Z',
      }),
      message({
        id: 'legacy-result',
        role: 'tool_result',
        content: 'legacy contents',
        createdAt: '2026-01-01T00:00:04.000Z',
      }),
      message({
        id: 'tool-pending',
        role: 'tool_use',
        content: { toolUseId: 'tu_pending', toolName: 'Bash', input: { command: 'sleep 10' } },
        createdAt: '2026-01-01T00:00:05.000Z',
      }),
    ]);

    const pairing = buildMessageToolResultPairing(sorted);

    expect(pairing.hasResultFor(sorted[0], parseMessageToolUse(sorted[0]))).toBe(true);
    expect(pairing.hasResultFor(sorted[2], parseMessageToolUse(sorted[2]))).toBe(true);
    expect(pairing.hasResultFor(sorted[4], parseMessageToolUse(sorted[4]))).toBe(false);
  });

  it('adjacency-pairs secondary tools of a merged multi-id result (PR #495 review)', () => {
    // desktop 持久层把一条 tool_result 归并多个 toolUseId 时只存 primary id:
    // secondary 工具(带自己的 id、byId 配不到)靠邻接兜底拿共享结果与 settled,
    // 与 desktop MessageStream Pass 2 口径一致。
    const sorted = sortMessagesByCreatedAt([
      message({
        id: 'use-a',
        role: 'tool_use',
        content: { toolUseId: 'tu_a', toolName: 'Read', input: { file_path: '/repo/a.ts' } },
        createdAt: '2026-01-01T00:00:01.000Z',
      }),
      message({
        id: 'use-b',
        role: 'tool_use',
        content: { toolUseId: 'tu_b', toolName: 'Read', input: { file_path: '/repo/b.ts' } },
        createdAt: '2026-01-01T00:00:02.000Z',
      }),
      // 合并行:代表 tu_a + tu_b,持久层只写 primary id tu_a。
      message({
        id: 'merged-result',
        role: 'tool_result',
        toolUseId: 'tu_a',
        content: 'merged contents of a and b',
        createdAt: '2026-01-01T00:00:03.000Z',
      }),
    ]);

    const pairing = buildMessageToolResultPairing(sorted);
    const secondaryB = parseMessageToolUse(sorted[1]);

    // primary 按 id 配对。
    expect(pairing.resultContentFor(sorted[0], parseMessageToolUse(sorted[0]))).toBe('merged contents of a and b');
    // secondary 靠邻接兜底:拿到共享内容,且计入 settled(不转圈)。
    expect(pairing.resultContentFor(sorted[1], secondaryB)).toBe('merged contents of a and b');
    expect(pairing.hasResultFor(sorted[1], secondaryB)).toBe(true);
  });

  it('does not let adjacency override a tool already settled by id, including hidden results', () => {
    // byId 已 settled(结果被 orca 空结果滤网隐藏)的工具,不得再被相邻其它
    // 工具的 result 邻接覆盖 —— 否则会展示别人的内容。
    const sorted = sortMessagesByCreatedAt([
      message({
        id: 'orca-tool',
        role: 'tool_use',
        content: { toolUseId: 'tu_orca', toolName: 'send_to_lead', input: {} },
        createdAt: '2026-01-01T00:00:01.000Z',
      }),
      message({
        id: 'orca-result',
        role: 'tool_result',
        toolUseId: 'tu_orca',
        content: JSON.stringify({ ok: true }),
        createdAt: '2026-01-01T00:00:02.000Z',
      }),
      message({
        id: 'other-result',
        role: 'tool_result',
        toolUseId: 'tu_other',
        content: 'someone else result',
        createdAt: '2026-01-01T00:00:03.000Z',
      }),
    ]);

    const pairing = buildMessageToolResultPairing(sorted);
    const orcaTool = parseMessageToolUse(sorted[0]);

    // 内容保持隐藏(不借用相邻行),settled 仍成立。
    expect(pairing.resultContentFor(sorted[0], orcaTool)).toBeUndefined();
    expect(pairing.hasResultFor(sorted[0], orcaTool)).toBe(true);
  });
});