@assistant-ui/core 0.2.12 → 0.2.15

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");
+  });
+});

package/src/types/message.ts

@@ -2,10 +2,10 @@ import type {
   ReadonlyJSONObject,
   ReadonlyJSONValue,
 } from "assistant-stream/utils";
-import type { ToolModelContentPart } from "assistant-stream";
+import type { ToolCallTiming, ToolModelContentPart } from "assistant-stream";
 import type { CompleteAttachment } from "./attachment";
 
-export type { ToolModelContentPart };
+export type { ToolCallTiming, ToolModelContentPart };
 
 export type TextMessagePart = {
   readonly type: "text";
@@ -135,6 +135,40 @@ export type ToolCallMessagePartMcpMetadata = {
   readonly app?: McpAppMetadata;
 };
 
+export type ToolApprovalOptionKind =
+  | "allow-once"
+  | "allow-always"
+  | "reject-once"
+  | "reject-always";
+
+export type ToolApprovalOption = {
+  /** Opaque, host-defined identifier. Scope semantics (session vs project vs global) belong to the option supplier. */
+  readonly id: string;
+  /**
+   * Decision class. Drives approved-resolution and default rendering.
+   * Open union: `_`-prefixed custom kinds are never auto-resolved and the
+   * default kit skips them; they must be answered with an explicit
+   * `approved` value (optionally alongside the `optionId`).
+   */
+  readonly kind: ToolApprovalOptionKind | (string & {});
+  /** Human label. Renderers supply defaults per kind when omitted. */
+  readonly label?: string;
+  readonly description?: string;
+  /** Patterns or rules this option would persist, shown before the user commits. Supplied by the host; never derived by the library. */
+  readonly grants?: readonly string[];
+  /** Opt-in confirmation step before this option resolves. */
+  readonly confirm?: boolean | { title?: string; description?: string };
+};
+
+export type ToolApprovalResponse =
+  | { readonly approved: boolean; readonly reason?: string }
+  | { readonly optionId: string; readonly reason?: string }
+  | {
+      readonly approved: boolean;
+      readonly optionId: string;
+      readonly reason?: string;
+    };
+
 export type ToolCallMessagePart<
   TArgs = ReadonlyJSONObject,
   TResult = unknown,
@@ -159,18 +193,26 @@ export type ToolCallMessagePart<
   readonly argsText: string;
   /** UI-only artifact associated with the tool result. */
   readonly artifact?: unknown;
+  /** Wall-clock timing for this call, when the runtime or host tracks it. */
+  readonly timing?: ToolCallTiming;
   /** MCP app metadata associated with this tool call, when present. */
   readonly mcp?: ToolCallMessagePartMcpMetadata;
   /** Content returned to the model for this tool result. */
   readonly modelContent?: readonly ToolModelContentPart[] | undefined;
   /** Human-input request that must be resolved before the run can continue. */
   readonly interrupt?: { type: "human"; payload: unknown };
-  /** Server-side approval gate. `approved === undefined` is the only state in which `respondToApproval` may be called. */
+  /** Server-side approval gate. `respondToApproval` may only be called while `approved` is undefined and no `resolution` is recorded. */
   readonly approval?: {
     readonly id: string;
     readonly approved?: boolean;
     readonly reason?: string;
     readonly isAutomatic?: boolean;
+    /** Available decisions for this call. Absent: a plain allow / deny pair. */
+    readonly options?: readonly ToolApprovalOption[];
+    /** The option chosen at resolution, when options were present. */
+    readonly optionId?: string;
+    /** Terminal non-decision state: the request was cancelled or expired without a user decision. Set by the host. */
+    readonly resolution?: "cancelled" | "expired";
   };
   /** Parent message-part ID when this part belongs to a nested structure. */
   readonly parentId?: string;