@assistant-ui/core 0.2.12 → 0.2.14

package/src/tests/groupMessageParts.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+import { groupMessageParts } from "../react/primitives/message/MessageParts";
+
+describe("groupMessageParts idKey", () => {
+  it("leaves idKey undefined when partIds is not provided", () => {
+    const ranges = groupMessageParts(["tool-call", "tool-call"], false);
+    expect(ranges).toEqual([{ type: "toolGroup", startIndex: 0, endIndex: 1 }]);
+  });
+
+  it("derives a tool group's idKey from its first part", () => {
+    const ranges = groupMessageParts(
+      ["text", "tool-call", "tool-call"],
+      false,
+      [undefined, "t1", "t2"],
+    );
+    expect(ranges).toEqual([
+      { type: "single", index: 0 },
+      { type: "toolGroup", startIndex: 1, endIndex: 2, idKey: "id:t1" },
+    ]);
+  });
+
+  it("keeps a group's idKey stable when the group shifts to a new index", () => {
+    const live = groupMessageParts(["text", "tool-call", "tool-call"], false, [
+      undefined,
+      "t1",
+      "t2",
+    ]);
+    const settled = groupMessageParts(
+      ["reasoning", "text", "tool-call", "tool-call"],
+      false,
+      [undefined, undefined, "t1", "t2"],
+    );
+    const liveGroup = live.find((r) => r.type === "toolGroup")!;
+    const settledGroup = settled.find((r) => r.type === "toolGroup")!;
+    expect(liveGroup.idKey).toBe("id:t1");
+    expect(settledGroup.idKey).toBe("id:t1");
+    expect(settledGroup).toMatchObject({ startIndex: 2, endIndex: 3 });
+  });
+
+  it("demotes a duplicate id in a later range to undefined", () => {
+    const ranges = groupMessageParts(
+      ["tool-call", "text", "tool-call"],
+      false,
+      ["t1", undefined, "t1"],
+    );
+    const groups = ranges.filter((r) => r.type === "toolGroup");
+    expect(groups.map((r) => r.idKey)).toEqual(["id:t1", undefined]);
+  });
+
+  it("does not assign an idKey to reasoning groups", () => {
+    const ranges = groupMessageParts(["reasoning", "reasoning"], false, [
+      undefined,
+      undefined,
+    ]);
+    expect(ranges).toEqual([
+      { type: "reasoningGroup", startIndex: 0, endIndex: 1 },
+    ]);
+  });
+
+  it("keeps a chain-of-thought group structural when it opens with reasoning", () => {
+    const ranges = groupMessageParts(["reasoning", "tool-call"], true, [
+      undefined,
+      "t1",
+    ]);
+    expect(ranges).toEqual([
+      { type: "chainOfThoughtGroup", startIndex: 0, endIndex: 1 },
+    ]);
+  });
+
+  it("derives a chain-of-thought group's idKey when it opens with a tool call", () => {
+    const ranges = groupMessageParts(["tool-call", "reasoning"], true, [
+      "t1",
+      undefined,
+    ]);
+    expect(ranges).toEqual([
+      {
+        type: "chainOfThoughtGroup",
+        startIndex: 0,
+        endIndex: 1,
+        idKey: "id:t1",
+      },
+    ]);
+  });
+});

package/src/tests/groupParts.test.ts

@@ -268,3 +268,58 @@ describe("groupPartByType", () => {
     expect(keyA).not.toBe(keyB);
   });
 });
+
+describe("buildGroupTree idKey", () => {
+  const ids = (values: readonly (string | undefined)[]) => values;
+
+  it("leaves idKey undefined when partIds is not provided", () => {
+    const tree = buildGroupTree(asPaths([["a"], ["a"]]));
+    const group = tree[0]!;
+    expect(group.idKey).toBeUndefined();
+    if (group.type === "group") {
+      expect(group.children.every((c) => c.idKey === undefined)).toBe(true);
+    }
+  });
+
+  it("derives group idKey from the first part of the group", () => {
+    const tree = buildGroupTree(asPaths([["a"], ["a"]]), ids(["t1", "t2"]));
+    const group = tree[0]!;
+    expect(group.idKey).toBe("id:t1");
+  });
+
+  it("keeps group idKey undefined when the first part has no id", () => {
+    const tree = buildGroupTree(
+      asPaths([["a"], ["a"]]),
+      ids([undefined, "t2"]),
+    );
+    expect(tree[0]!.idKey).toBeUndefined();
+  });
+
+  it("assigns leaf idKeys and lets a group and its first leaf share an id across levels", () => {
+    const tree = buildGroupTree(asPaths([["a"], ["a"]]), ids(["t1", "t2"]));
+    const group = tree[0]!;
+    if (group.type !== "group") throw new Error("expected group");
+    expect(group.idKey).toBe("id:t1");
+    expect(group.children.map((c) => c.idKey)).toEqual(["id:t1", "id:t2"]);
+  });
+
+  it("demotes duplicate ids among siblings to undefined", () => {
+    const tree = buildGroupTree(asPaths([[], [], []]), ids(["t1", "t1", "t2"]));
+    expect(tree.map((n) => n.idKey)).toEqual(["id:t1", undefined, "id:t2"]);
+  });
+
+  it("keeps a group's idKey stable when parts reorder across rebuilds", () => {
+    const live = buildGroupTree(
+      asPaths([[], ["a"], [], ["a"]]),
+      ids([undefined, "t1", undefined, "t2"]),
+    );
+    const settled = buildGroupTree(
+      asPaths([[], [], ["a"], ["a"]]),
+      ids([undefined, undefined, "t1", "t2"]),
+    );
+    const liveFirstGroup = live.find((n) => n.type === "group")!;
+    const settledGroup = settled.find((n) => n.type === "group")!;
+    expect(liveFirstGroup.idKey).toBe("id:t1");
+    expect(settledGroup.idKey).toBe("id:t1");
+  });
+});