import test from "node:test";
import assert from "node:assert/strict";
import { runAgent } from "../src/agent.js";
import { renderMiniCPMPrompt, normalizedCall } from "../src/prompt.js";
import { DEFAULTS } from "../src/core.js";
const call = (args) => ({
  index: 0,
  id: "test-call",
  function: { name: "create_html", arguments: args },
});
const chunk = (delta, finish) => ({
  choices: [{ delta, finish_reason: finish }],
});
test("an unterminated tool call is reported, repaired with a larger budget, executed and followed up", async () => {
  const history = [{ role: "user", content: "Create a black hole in HTML" }];
  let requests = 0,
    created = 0;
  async function chat(messages, settings, tools, signal, emit) {
    requests++;
    if (requests === 1) {
      await emit(
        chunk(
          { tool_calls: [call('{"title":"Black hole","html":"<html>')] },
          "length",
        ),
      );
      return;
    }
    assert.doesNotThrow(() => renderMiniCPMPrompt(messages, { tools: [] }));
    for (const m of messages)
      for (const c of m.tool_calls || [])
        assert.doesNotThrow(() => JSON.parse(c.function.arguments));
    if (requests === 2) {
      assert.ok(settings.maxTokens >= 8192);
      assert.equal(settings.thinking, false);
      assert.match(messages.at(-1).content, /cut off/);
      await emit(
        chunk(
          {
            tool_calls: [
              call(
                JSON.stringify({
                  title: "Black hole",
                  html: "<!doctype html><h1>Black hole</h1>",
                }),
              ),
            ],
          },
          "tool_calls",
        ),
      );
      return;
    }
    assert.equal(JSON.parse(messages.at(-1).content).success, true);
    await emit(chunk({ content: "Your black hole is ready." }, "stop"));
  }
  const events = [];
  await runAgent({
    chat,
    history,
    settings: { ...DEFAULTS, maxTokens: 1536, thinking: true },
    signal: new AbortController().signal,
    createArtifact: async (name, args) => {
      created++;
      assert.ok(args.html.includes("<h1>"));
      return { id: "file", filename: "Black-hole.html" };
    },
    onEvent: (event) => events.push(event),
  });
  assert.equal(requests, 3);
  assert.equal(created, 1);
  assert.equal(events.find((e) => e.type === "tool-success").recovered, true);
  assert.equal(events.at(-1).type, "done");
});
test("tool validation errors are fed back and do not terminate the turn", async () => {
  let requests = 0,
    attempts = 0;
  const history = [{ role: "user", content: "Make a file" }];
  async function chat(messages, settings, tools, signal, emit) {
    requests++;
    if (requests < 3) {
      if (requests === 2) assert.match(messages.at(-1).content, /closing tag/);
      await emit(
        chunk(
          {
            tool_calls: [
              call(
                JSON.stringify({
                  title: "Page",
                  html:
                    requests === 1
                      ? '</span id="x">'
                      : '<span id="x">Fixed</span>',
                }),
              ),
            ],
          },
          "stop",
        ),
      );
    } else await emit(chunk({ content: "Done" }, "stop"));
  }
  await runAgent({
    chat,
    history,
    settings: DEFAULTS,
    signal: new AbortController().signal,
    createArtifact: async (_, args) => {
      attempts++;
      if (args.html.startsWith("</")) throw Error("Invalid closing tag");
      return { id: "file", filename: "Page.html" };
    },
  });
  assert.equal(requests, 3);
  assert.equal(attempts, 2);
});
test("tool history serializes structured values once", () => {
  const c = {
    id: "x",
    function: {
      name: "create_spreadsheet",
      arguments: JSON.stringify({ sheets: [{ rows: [[1, true, null]] }] }),
    },
  };
  const prompt = renderMiniCPMPrompt([
    { role: "user", content: "Make a sheet" },
    { role: "assistant", content: "", tool_calls: [c] },
    { role: "tool", content: "success" },
  ]);
  assert.equal(prompt.match(/<function name=/g).length, 1);
  assert.ok(prompt.includes('[{"rows":[[1,true,null]]}]'));
  assert.ok(prompt.includes("<tool_response>\nsuccess"));
});
test("malformed older history remains representable", () => {
  const c = normalizedCall({
    function: { name: "create_html", arguments: '{"html":"unfinished' },
  });
  assert.equal(
    JSON.parse(c.function.arguments).invalid_arguments,
    '{"html":"unfinished',
  );
});
test("consumer errors propagate and cancellation stops callback streaming", async () => {
  const controller = new AbortController();
  let delivered = 0;
  const chat = async (m, s, t, signal, emit) => {
    for (let i = 0; i < 10000; i++) {
      signal.throwIfAborted();
      await emit(chunk({ content: "x" }, null));
    }
  };
  await assert.rejects(
    runAgent({
      chat,
      history: [],
      settings: DEFAULTS,
      signal: controller.signal,
      createArtifact: () => {},
      onEvent: (e) => {
        if (e.type === "chunk" && ++delivered === 500) controller.abort();
      },
    }),
    { name: "AbortError" },
  );
  assert.equal(delivered, 500);
  await assert.rejects(
    runAgent({
      chat,
      history: [],
      settings: DEFAULTS,
      signal: new AbortController().signal,
      createArtifact: () => {},
      onEvent: (e) => {
        if (e.type === "chunk") throw Error("consumer failed");
      },
    }),
    /consumer failed/,
  );
});