message-builder.test.ts

/**
 * Message Builder 单元测试
 *
 * 测试 messages[] 数组的全生命周期：
 *   - 初始消息构建（system + user）
 *   - assistant 消息追加
 *   - tool 结果消息追加
 *   - Message[] -> DeepSeekApiMessage[] 转换
 *   - reasoning_content 回传处理
 */

import { describe, it, expect } from "bun:test";
import {
  buildInitialMessages,
  appendAssistant,
  appendToolResult,
  toApiMessages,
  SYSTEM_PROMPT,
  computeHash,
  findLastAssistantMessage,
} from "../src/message-builder.js";
import type { Message, DeepSeekApiMessage, ApiResponse } from "../src/types.js";

// ── Tests: SYSTEM_PROMPT ────────────────────────────────────────────────

describe("SYSTEM_PROMPT", () => {
  it("should not be empty", () => {
    expect(SYSTEM_PROMPT.length).toBeGreaterThan(0);
  });

  it("should instruct about ReAct loop", () => {
    expect(SYSTEM_PROMPT).toContain("ReAct");
  });

  it("should instruct to use tools", () => {
    expect(SYSTEM_PROMPT).toMatch(/bash|read|write|edit|glob|grep/);
  });

  it("should instruct to think before acting", () => {
    expect(SYSTEM_PROMPT).toMatch(/THINK/);
  });

  it("should forbid guessing file contents", () => {
    expect(SYSTEM_PROMPT).toMatch(/NEVER guess/);
  });

  it("should require production-quality code", () => {
    expect(SYSTEM_PROMPT).toMatch(/PRODUCTION-QUALITY/);
  });
});

// ── Tests: buildInitialMessages ─────────────────────────────────────────

describe("buildInitialMessages", () => {
  it("should return array with 2 messages", () => {
    const msgs = buildInitialMessages("Write a Hello World");
    expect(msgs.length).toBe(2);
  });

  it("should have system as first message", () => {
    const msgs = buildInitialMessages("Test task");
    expect(msgs[0].role).toBe("system");
  });

  it("should have user as second message", () => {
    const msgs = buildInitialMessages("Test task");
    expect(msgs[1].role).toBe("user");
  });

  it("should use SYSTEM_PROMPT as system message content", () => {
    const msgs = buildInitialMessages("Test task");
    expect(msgs[0].content).toBe(SYSTEM_PROMPT);
  });

  it("should use task as user message content", () => {
    const task = "Build a CLI calculator in Rust";
    const msgs = buildInitialMessages(task);
    expect(msgs[1].content).toBe(task);
  });

  it("should return Message type objects", () => {
    const msgs = buildInitialMessages("Test");
    for (const msg of msgs) {
      expect(msg.role).toBeDefined();
      expect(msg.content).toBeDefined();
    }
  });
});

// ── Tests: appendAssistant ────────────────────────────────────────

describe("appendAssistant", () => {
  it("should append assistant message to array", () => {
    const messages: Message[] = [
      { role: "system", content: "sys" },
      { role: "user", content: "hello" },
    ];

    const apiResp: ApiResponse = {
      content: "Yes, I can help.",
      reasoningContent: "User needs help. I'll respond.",
      toolCalls: [],
      finishReason: "stop",
      usage: { promptTokens: 100, completionTokens: 50, reasoningTokens: 200 },
    };

    appendAssistant(apiResp, messages);
    expect(messages.length).toBe(3);
    expect(messages[2].role).toBe("assistant");
  });

  it("should preserve reasoning_content in appended message", () => {
    const messages: Message[] = [
      { role: "user", content: "hi" },
    ];

    const resp: ApiResponse = {
      content: "Hello!",
      reasoningContent: "Greeting the user.",
      toolCalls: [],
      finishReason: "stop",
      usage: { promptTokens: 50, completionTokens: 20, reasoningTokens: 100 },
    };

    appendAssistant(resp, messages);
    expect(messages[1].reasoning_content).toBe("Greeting the user.");
  });

  it("should include tool_calls when present", () => {
    const messages: Message[] = [
      { role: "user", content: "read /tmp/test" },
    ];

    const resp: ApiResponse = {
      content: null,
      reasoningContent: "I need to read a file.",
      toolCalls: [
        { id: "c1", type: "function", index: 0, function: { name: "read", arguments: '{"file_path":"/tmp/test"}' } },
      ],
      finishReason: "tool_calls",
      usage: { promptTokens: 80, completionTokens: 30, reasoningTokens: 150 },
    };

    appendAssistant(resp, messages);
    expect(messages[1].tool_calls).toBeDefined();
    expect(messages[1].tool_calls!.length).toBe(1);
  });
});

// ── Tests: appendToolResult ──────────────────────────────────────────────

describe("appendToolResult", () => {
  it("should append tool result message", () => {
    const messages: Message[] = [
      { role: "user", content: "test" },
    ];

    appendToolResult("call_001", "read", "line 1\nline 2\n", messages);
    expect(messages.length).toBe(2);
    expect(messages[1].role).toBe("tool");
    expect(messages[1].tool_call_id).toBe("call_001");
    expect(messages[1].content).toBe("line 1\nline 2\n");
  });

  it("should handle empty tool result", () => {
    const messages: Message[] = [{ role: "user", content: "test" }];
    appendToolResult("call_002", "bash", "", messages);
    expect(messages[1].content).toBe("");
  });

  it("should handle multi-line tool result", () => {
    const messages: Message[] = [{ role: "user", content: "test" }];
    const output = "file1.ts\nfile2.ts\nfile3.ts\n";
    appendToolResult("call_003", "glob", output, messages);
    expect(messages[1].content).toBe(output);
  });
});

// ── Tests: toApiMessages ────────────────────────────────────────────────

describe("toApiMessages", () => {
  it("should convert Message[] to DeepSeekApiMessage[]", () => {
    const messages: Message[] = [
      { role: "system", content: "You are helpful." },
      { role: "user", content: "Hello" },
      { role: "assistant", content: "Hi!", reasoning_content: "Greeting" },
    ];

    const apiMessages: DeepSeekApiMessage[] = toApiMessages(messages);
    expect(apiMessages.length).toBe(3);
    expect(apiMessages[0].role).toBe("system");
    expect(apiMessages[1].role).toBe("user");
  });

  it("should preserve reasoning_content during conversion", () => {
    const messages: Message[] = [
      { role: "assistant", content: "Done", reasoning_content: "Plan executed." },
    ];

    const converted = toApiMessages(messages);
    expect(converted[0].reasoning_content).toBe("Plan executed.");
  });

  it("should not strip undefined reasoning_content", () => {
    const messages: Message[] = [
      { role: "assistant", content: "ok" }, // no reasoning_content key
    ];

    const converted = toApiMessages(messages);
    // Should not add undefined keys
    expect("reasoning_content" in converted[0]).toBe(false);
  });

  it("should handle empty reasoning_content", () => {
    const messages: Message[] = [
      { role: "assistant", content: "Yes", reasoning_content: "" },
    ];

    const converted = toApiMessages(messages);
    // Empty string should be preserved (model chose not to think)
    expect(converted[0].reasoning_content).toBe("");
  });
});

// ── Tests: Message properties ───────────────────────────────────────────

describe("Message type validation", () => {
  it("should accept valid system message", () => {
    const msg: Message = { role: "system", content: "You are a coder." };
    expect(msg.role).toBe("system");
    expect(msg.content).toBeTruthy();
  });

  it("should accept valid user message", () => {
    const msg: Message = { role: "user", content: "Write code" };
    expect(msg.role).toBe("user");
  });

  it("should accept valid assistant message with reasoning", () => {
    const msg: Message = {
      role: "assistant",
      content: "Let me think...",
      reasoning_content: "Deep analysis of the problem...",
    };
    expect(msg.reasoning_content).toBeTruthy();
  });

  it("should accept valid tool message", () => {
    const msg: Message = {
      role: "tool",
      content: "stdout: success",
      tool_call_id: "call_001",
    };
    expect(msg.tool_call_id).toBe("call_001");
  });
});

// ── Tests: computeHash ─────────────────────────────────────────────────

describe("computeHash", () => {
  it("should return a 16-char hex string", () => {
    const hash = computeHash("test content", []);
    expect(hash.length).toBe(16);
    expect(hash).toMatch(/^[0-9a-f]{16}$/);
  });

  it("should produce different hashes for different content", () => {
    const h1 = computeHash("alpha", []);
    const h2 = computeHash("beta", []);
    expect(h1).not.toBe(h2);
  });

  it("should produce same hash for same input", () => {
    const toolResults = [{ toolName: "bash", toolCallId: "c1", content: "ok" }];
    const h1 = computeHash("content", toolResults);
    const h2 = computeHash("content", toolResults);
    expect(h1).toBe(h2);
  });

  it("should factor tool results into hash", () => {
    const h1 = computeHash("content", [{ toolName: "bash", toolCallId: "c1", content: "ok" }]);
    const h2 = computeHash("content", [{ toolName: "bash", toolCallId: "c1", content: "FAIL" }]);
    expect(h1).not.toBe(h2);
  });

  it("should handle null content", () => {
    const hash = computeHash(null, [{ toolName: "read", toolCallId: "c2", content: "file contents" }]);
    expect(hash.length).toBe(16);
    expect(hash).toMatch(/^[0-9a-f]{16}$/);
  });

  it("should truncate tool result content to 256 chars in hash input", () => {
    const longContent = "x".repeat(500);
    // Should not throw
    const hash = computeHash("content", [{ toolName: "read", toolCallId: "c3", content: longContent }]);
    expect(hash.length).toBe(16);
  });

  it("should handle empty toolResults array", () => {
    const hash = computeHash("solo content", []);
    expect(hash.length).toBe(16);
    expect(hash).toMatch(/^[0-9a-f]{16}$/);
  });
});

// ── Tests: findLastAssistantMessage ────────────────────────────────────

describe("findLastAssistantMessage", () => {
  it("should return the last assistant message", () => {
    const messages: Message[] = [
      { role: "system", content: "sys" },
      { role: "user", content: "hello" },
      { role: "assistant", content: "first reply" },
      { role: "user", content: "second question" },
      { role: "assistant", content: "second reply", reasoning_content: "thinking..." },
    ];
    const found = findLastAssistantMessage(messages);
    expect(found).not.toBeNull();
    expect(found!.content).toBe("second reply");
    expect(found!.reasoning_content).toBe("thinking...");
  });

  it("should return null when no assistant messages exist", () => {
    const messages: Message[] = [
      { role: "system", content: "sys" },
      { role: "user", content: "hello" },
      { role: "tool", content: "result", tool_call_id: "c1" },
    ];
    expect(findLastAssistantMessage(messages)).toBeNull();
  });

  it("should return null for empty array", () => {
    expect(findLastAssistantMessage([])).toBeNull();
  });

  it("should find the only assistant message", () => {
    const messages: Message[] = [
      { role: "system", content: "sys" },
      { role: "assistant", content: "only reply" },
    ];
    const found = findLastAssistantMessage(messages);
    expect(found).not.toBeNull();
    expect(found!.content).toBe("only reply");
  });

  it("should return the last assistant when multiple exist", () => {
    const messages: Message[] = [
      { role: "assistant", content: "first" },
      { role: "tool", content: "r1", tool_call_id: "c1" },
      { role: "assistant", content: "second" },
      { role: "tool", content: "r2", tool_call_id: "c2" },
      { role: "assistant", content: "third" },
    ];
    const found = findLastAssistantMessage(messages);
    expect(found).not.toBeNull();
    expect(found!.content).toBe("third");
  });

  it("should not mutate the input array", () => {
    const messages: Message[] = [
      { role: "system", content: "sys" },
      { role: "assistant", content: "reply" },
    ];
    const originalLength = messages.length;
    findLastAssistantMessage(messages);
    expect(messages.length).toBe(originalLength);
  });
});