@assistant-ui/core 0.2.5 → 0.2.7

package/src/store/clients/thread-message-client.ts

@@ -38,6 +38,9 @@ const ThreadMessagePartClient = resource(
       resumeToolCall: () => {
         throw new Error("Not supported");
       },
+      respondToToolApproval: () => {
+        throw new Error("Not supported");
+      },
     };
   },
 );

package/src/store/runtime-clients/message-part-runtime-client.ts

@@ -11,6 +11,8 @@ export const MessagePartClient = resource(
       getState: () => state,
       addToolResult: (result) => runtime.addToolResult(result),
       resumeToolCall: (payload) => runtime.resumeToolCall(payload),
+      respondToToolApproval: (response) =>
+        runtime.respondToToolApproval(response),
       __internal_getRuntime: () => runtime,
     };
   },

package/src/store/scopes/part.ts

@@ -26,6 +26,10 @@ export type PartMethods = {
    * This is useful when a tool has requested human input and is waiting for a response.
    */
   resumeToolCall(payload: unknown): void;
+  /**
+   * Respond to a server-side tool approval gate. The approval id is read from the part.
+   */
+  respondToToolApproval(response: { approved: boolean; reason?: string }): void;
   __internal_getRuntime?(): MessagePartRuntime;
 };
 

package/src/subscribable/subscribable.ts

@@ -207,9 +207,9 @@ export class LazyMemoizeSubject<TState extends object, TPath>
 }
 
 export class NestedSubscriptionSubject<
-    TState extends Subscribable | undefined,
-    TPath,
-  >
+  TState extends Subscribable | undefined,
+  TPath,
+>
   extends BaseSubject
   implements
     SubscribableWithState<TState, TPath>,

package/src/tests/OptimisticState-delete-crash.test.ts

@@ -24,6 +24,8 @@ const createThreadState = (
   const mappingId = createThreadMappingId(threadId);
   return {
     isLoading: false,
+    isLoadingMore: false,
+    cursor: undefined,
     newThreadId: undefined,
     threadIds: status === "regular" ? [threadId] : [],
     archivedThreadIds: status === "archived" ? [threadId] : [],

package/src/tests/OptimisticState-list-race.test.ts

@@ -22,6 +22,8 @@ import { deferred } from "./remote-thread-list-test-helpers";
 
 const EMPTY_STATE: RemoteThreadState = {
   isLoading: false,
+  isLoadingMore: false,
+  cursor: undefined,
   newThreadId: undefined,
   threadIds: [],
   archivedThreadIds: [],

package/src/tests/RemoteThreadListThreadListRuntimeCore-loadMore.test.ts

@@ -20,7 +20,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
 
   it("initial list response with nextCursor sets hasMore=true", async () => {
     const adapter = makeAdapter({
-      list: vi.fn(async () => ({
+      list: vi.fn<ListFn>(async () => ({
         threads: [
           {
             status: "regular",
@@ -41,7 +41,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
 
   it("absent nextCursor leaves hasMore=false", async () => {
     const adapter = makeAdapter({
-      list: vi.fn(async () => ({
+      list: vi.fn<ListFn>(async () => ({
         threads: [
           {
             status: "regular",
@@ -243,7 +243,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
 
   it("__internal_setOptions clears cursor and dedup handles on adapter swap, then refetches via the new adapter", async () => {
     const firstAdapter = makeAdapter({
-      list: vi.fn(async () => ({
+      list: vi.fn<ListFn>(async () => ({
         threads: [{ status: "regular", remoteId: "old", externalId: "old" }],
         nextCursor: "old-cursor",
       })),
@@ -253,7 +253,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     expect(core.threadIds).toEqual(["old"]);
     expect(core.hasMore).toBe(true);
 
-    const secondList = vi.fn(async () => ({
+    const secondList = vi.fn<ListFn>(async () => ({
       threads: [{ status: "regular", remoteId: "new", externalId: "new" }],
     }));
     const secondAdapter = makeAdapter({ list: secondList });
@@ -290,7 +290,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     const stale = core.loadMore();
 
     const secondAdapter = makeAdapter({
-      list: vi.fn(async () => ({
+      list: vi.fn<ListFn>(async () => ({
         threads: [{ status: "regular", remoteId: "ignored", externalId: "x" }],
       })),
     });

package/src/tests/auiV0Encode.test.ts

@@ -9,7 +9,7 @@ describe("auiV0Encode", () => {
       role: "assistant",
       status: { type: "complete", reason: "stop" },
       metadata: {
-        unstable_state: undefined,
+        unstable_state: null,
         unstable_annotations: [],
         unstable_data: [],
         steps: [],

package/src/tests/composer-can-send.test.ts

@@ -102,10 +102,14 @@ describe("BaseComposerRuntimeCore.send", () => {
 describe("DefaultEditComposerRuntimeCore.canSend", () => {
   it("ignores runtime.isSendDisabled (thread-scoped flag does not block edits)", () => {
     const stub = makeRuntimeStub({ isSendDisabled: true });
-    const composer = new DefaultEditComposerRuntimeCore(stub, () => {}, {
-      parentId: null,
-      message: makeUserMessage("seed"),
-    });
+    const composer = new DefaultEditComposerRuntimeCore(
+      stub as unknown as ThreadRuntimeCore,
+      () => {},
+      {
+        parentId: null,
+        message: makeUserMessage("seed"),
+      },
+    );
 
     expect(composer.canSend).toBe(true);
   });

package/src/tests/duplicate-detection.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { checkDuplicateCore } from "../internal/duplicate-detection";
+
+const KEY = Symbol.for("@assistant-ui/core.loaded");
+
+function reset(): void {
+  delete (globalThis as unknown as Record<symbol, unknown>)[KEY];
+}
+
+describe("checkDuplicateCore", () => {
+  let warn: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    reset();
+    warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warn.mockRestore();
+    reset();
+  });
+
+  it("does not warn on the first load", () => {
+    checkDuplicateCore();
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("warns when a second copy registers in the same runtime", () => {
+    checkDuplicateCore();
+    checkDuplicateCore();
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]![0]).toMatch(/npx assistant-ui doctor/);
+  });
+});

package/src/tests/external-store-thread-list-runtime-core.test.ts

@@ -184,7 +184,7 @@ describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl"
     const core = new ExternalStoreThreadListRuntimeCore(adapter, makeFactory());
     return new ThreadListRuntimeImpl(
       core,
-      NoopThreadRuntime as unknown as Parameters<
+      NoopThreadRuntime as unknown as ConstructorParameters<
         typeof ThreadListRuntimeImpl
       >[1],
     );

package/src/tests/external-store-thread-runtime-core.test.ts

@@ -8,12 +8,13 @@ const mockContextProvider: ModelContextProvider = {
 };
 
 const makeStore = (
-  overrides?: Partial<ExternalStoreAdapter>,
-): ExternalStoreAdapter => ({
-  messages: [],
-  onNew: vi.fn(),
-  ...overrides,
-});
+  overrides?: Partial<ExternalStoreAdapter> | Record<string, unknown>,
+): ExternalStoreAdapter =>
+  ({
+    messages: [],
+    onNew: vi.fn(),
+    ...overrides,
+  }) as ExternalStoreAdapter;
 
 describe("ExternalStoreThreadRuntimeCore - state reference stability", () => {
   describe("capabilities", () => {

package/src/tests/groupParts.test.ts

@@ -1,12 +1,13 @@
 import { describe, expect, it } from "vitest";
+import type { PartState } from "../store/scopes/part";
 import {
   buildGroupTree,
-  normalizeGroupKey,
+  GROUPBY_MEMO_KEY,
+  groupPartByType,
   type GroupNode,
 } from "../react/utils/groupParts";
 
-const asPaths = (keys: readonly (string | readonly string[] | null)[]) =>
-  keys.map((k) => normalizeGroupKey(k));
+const asPaths = (keys: readonly (readonly string[])[]) => keys;
 
 // Compact tree dump: "G:key#nodeKey[i,j]{...}" | "P:#nodeKey(i)"
 const dump = (nodes: readonly GroupNode[]): string =>
@@ -20,39 +21,23 @@ const dump = (nodes: readonly GroupNode[]): string =>
     })
     .join(",");
 
-describe("normalizeGroupKey", () => {
-  it("maps null/undefined/[] to []", () => {
-    expect(normalizeGroupKey(null)).toEqual([]);
-    expect(normalizeGroupKey(undefined)).toEqual([]);
-    expect(normalizeGroupKey([])).toEqual([]);
-  });
-
-  it("wraps a string into a single-element array", () => {
-    expect(normalizeGroupKey("foo")).toEqual(["foo"]);
-  });
-
-  it("passes arrays through", () => {
-    expect(normalizeGroupKey(["a", "b"])).toEqual(["a", "b"]);
-  });
-});
-
 describe("buildGroupTree", () => {
   it("returns an empty list for no parts", () => {
     expect(buildGroupTree([])).toEqual([]);
   });
 
   it("emits one part leaf per ungrouped part (no coalescing)", () => {
-    const tree = buildGroupTree(asPaths([null, null, null]));
+    const tree = buildGroupTree(asPaths([[], [], []]));
     expect(dump(tree)).toBe("P:#0(0),P:#1(1),P:#2(2)");
   });
 
   it("wraps adjacent same-key parts in one group with one part child each", () => {
-    const tree = buildGroupTree(asPaths(["a", "a", "a"]));
+    const tree = buildGroupTree(asPaths([["a"], ["a"], ["a"]]));
     expect(dump(tree)).toBe("G:a#0[0,1,2]{P:#0.0(0),P:#0.1(1),P:#0.2(2)}");
   });
 
   it("splits non-adjacent runs of the same key into separate groups", () => {
-    const tree = buildGroupTree(asPaths(["a", null, "a"]));
+    const tree = buildGroupTree(asPaths([["a"], [], ["a"]]));
     expect(dump(tree)).toBe("G:a#0[0]{P:#0.0(0)},P:#1(1),G:a#2[2]{P:#2.0(2)}");
   });
 
@@ -95,20 +80,121 @@ describe("buildGroupTree", () => {
     );
   });
 
-  it("accepts strings and arrays interchangeably via normalizeGroupKey", () => {
-    const tree = buildGroupTree([
-      normalizeGroupKey("A"),
-      normalizeGroupKey(["A"]),
-    ]);
-    expect(dump(tree)).toBe("G:A#0[0,1]{P:#0.0(0),P:#0.1(1)}");
-  });
-
   it("assigns stable nodeKeys under append (existing keys do not shift)", () => {
-    const before = buildGroupTree(asPaths([["A"], null]));
-    const after = buildGroupTree(asPaths([["A"], null, ["B"]]));
+    const before = buildGroupTree(asPaths([["A"], []]));
+    const after = buildGroupTree(asPaths([["A"], [], ["B"]]));
 
     expect(before[0]!.nodeKey).toBe(after[0]!.nodeKey);
     expect(before[1]!.nodeKey).toBe(after[1]!.nodeKey);
     expect(after[2]!.nodeKey).toBe("2");
   });
 });
+
+const part = (overrides: Partial<PartState>): PartState =>
+  ({
+    type: "text",
+    text: "",
+    status: { type: "complete" },
+    ...overrides,
+  }) as PartState;
+
+describe("groupPartByType", () => {
+  it("maps part.type to the configured path", () => {
+    const fn = groupPartByType({
+      reasoning: ["group-thought", "group-reasoning"],
+      "tool-call": ["group-thought", "group-tool"],
+    });
+    expect(fn(part({ type: "reasoning" }))).toEqual([
+      "group-thought",
+      "group-reasoning",
+    ]);
+    expect(fn(part({ type: "tool-call" }))).toEqual([
+      "group-thought",
+      "group-tool",
+    ]);
+  });
+
+  it("returns [] for part types not in the map", () => {
+    const fn = groupPartByType({ reasoning: ["group-r"] });
+    expect(fn(part({ type: "text" }))).toEqual([]);
+  });
+
+  it("routes MCP-app tool calls through the 'mcp-app' entry when present", () => {
+    const fn = groupPartByType({
+      "tool-call": ["group-tool"],
+      "mcp-app": [],
+    });
+    const mcpApp = part({
+      type: "tool-call",
+      toolName: "render",
+      mcp: { app: { resourceUri: "ui://my-app" } },
+    } as Partial<PartState>);
+    const regular = part({
+      type: "tool-call",
+      toolName: "search",
+    } as Partial<PartState>);
+    expect(fn(mcpApp)).toEqual([]);
+    expect(fn(regular)).toEqual(["group-tool"]);
+  });
+
+  it("falls back to 'tool-call' for MCP-app parts when 'mcp-app' is absent", () => {
+    const fn = groupPartByType({ "tool-call": ["group-tool"] });
+    const mcpApp = part({
+      type: "tool-call",
+      toolName: "render",
+      mcp: { app: { resourceUri: "ui://x" } },
+    } as Partial<PartState>);
+    expect(fn(mcpApp)).toEqual(["group-tool"]);
+  });
+
+  it("does not route non-`ui://` tool calls through 'mcp-app'", () => {
+    const fn = groupPartByType({
+      "tool-call": ["group-tool"],
+      "mcp-app": ["group-mcp"],
+    });
+    const notMcp = part({
+      type: "tool-call",
+      toolName: "x",
+      mcp: { app: { resourceUri: "http://example.com" } },
+    } as Partial<PartState>);
+    expect(fn(notMcp)).toEqual(["group-tool"]);
+  });
+
+  it("tags the function with a GROUPBY_MEMO_KEY fingerprint", () => {
+    const fn = groupPartByType({ reasoning: ["group-r"] });
+    const memoKey = (fn as unknown as { [GROUPBY_MEMO_KEY]: string })[
+      GROUPBY_MEMO_KEY
+    ];
+    expect(memoKey).toMatch(/^groupPartByType:/);
+  });
+
+  it("produces the same fingerprint regardless of map key order", () => {
+    const a = groupPartByType({
+      reasoning: ["group-r"],
+      "tool-call": ["group-t"],
+    });
+    const b = groupPartByType({
+      "tool-call": ["group-t"],
+      reasoning: ["group-r"],
+    });
+    const keyA = (a as unknown as { [GROUPBY_MEMO_KEY]: string })[
+      GROUPBY_MEMO_KEY
+    ];
+    const keyB = (b as unknown as { [GROUPBY_MEMO_KEY]: string })[
+      GROUPBY_MEMO_KEY
+    ];
+    expect(keyA).toBe(keyB);
+  });
+
+  it("produces different fingerprints for different configs", () => {
+    const a = groupPartByType({ reasoning: ["group-r"] });
+    const b = groupPartByType({ reasoning: ["group-r2"] });
+    const keyA = (a as unknown as { [GROUPBY_MEMO_KEY]: string })[
+      GROUPBY_MEMO_KEY
+    ];
+    const keyB = (b as unknown as { [GROUPBY_MEMO_KEY]: string })[
+      GROUPBY_MEMO_KEY
+    ];
+    expect(keyA).not.toBe(keyB);
+  });
+});

package/src/tests/no-unsafe-process-env.test.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { describe, expect, it } from "vitest";
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { resolve, relative, join } from "node:path";

package/src/tests/remote-thread-list-isLoading.test.ts

@@ -26,6 +26,8 @@ type ListResult = {
 
 const INITIAL_STATE: RemoteThreadState = {
   isLoading: true,
+  isLoadingMore: false,
+  cursor: undefined,
   newThreadId: undefined,
   threadIds: [],
   archivedThreadIds: [],

package/src/tests/thread-message-like.test.ts

@@ -2,7 +2,10 @@ import { describe, expect, it } from "vitest";
 import { fromThreadMessageLike } from "../runtime/utils/thread-message-like";
 
 const fallbackId = "test-id";
-const fallbackStatus = { type: "complete" as const };
+const fallbackStatus = {
+  type: "complete" as const,
+  reason: "stop" as const,
+};
 
 describe("fromThreadMessageLike", () => {
   describe("data-* prefixed types", () => {

package/src/types/index.ts

@@ -49,7 +49,4 @@ export type {
   Unstable_DirectiveFormatter,
 } from "./directive";
 
-export type {
-  Unstable_TriggerItem,
-  Unstable_TriggerCategory,
-} from "./trigger";
+export type { Unstable_TriggerItem, Unstable_TriggerCategory } from "./trigger";

package/src/types/message.ts

@@ -165,6 +165,13 @@ export type ToolCallMessagePart<
   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. */
+  readonly approval?: {
+    readonly id: string;
+    readonly approved?: boolean;
+    readonly reason?: string;
+    readonly isAutomatic?: boolean;
+  };
   /** Parent message-part ID when this part belongs to a nested structure. */
   readonly parentId?: string;
   /**

package/dist/react/runtimes/useToolInvocations.d.ts

@@ -1,53 +0,0 @@
-import { ThreadMessage } from "../../types/message.js";
-import { Tool, ToolModelContentPart } from "assistant-stream";
-import { ReadonlyJSONValue } from "assistant-stream/utils";
-
-//#region src/react/runtimes/useToolInvocations.d.ts
-type AssistantTransportState = {
-  readonly messages: readonly ThreadMessage[];
-  readonly state?: ReadonlyJSONValue;
-  readonly isRunning: boolean;
-};
-type AddToolResultCommand = {
-  readonly type: "add-tool-result";
-  readonly toolCallId: string;
-  readonly toolName: string;
-  readonly result: ReadonlyJSONValue;
-  readonly isError: boolean;
-  readonly artifact?: ReadonlyJSONValue;
-  readonly modelContent?: readonly ToolModelContentPart[];
-};
-type UseToolInvocationsParams = {
-  state: AssistantTransportState;
-  getTools: () => Record<string, Tool> | undefined;
-  onResult: (command: AddToolResultCommand) => void;
-  setToolStatuses: (updater: Record<string, ToolExecutionStatus> | ((prev: Record<string, ToolExecutionStatus>) => Record<string, ToolExecutionStatus>)) => void;
-};
-/**
- * Streaming execution state for a frontend tool.
- *
- * Custom runtime integrations use this to mirror in-flight tool calls while
- * `useToolInvocations` executes tools in the browser.
- */
-type ToolExecutionStatus = {
-  /** The tool's execute function is currently running. */type: "executing";
-} | {
-  /** The tool is waiting for a human input payload before continuing. */type: "interrupt"; /** Human input request emitted by the tool execution context. */
-  payload: {
-    type: "human";
-    payload: unknown;
-  };
-};
-declare function useToolInvocations({
-  state,
-  getTools,
-  onResult,
-  setToolStatuses
-}: UseToolInvocationsParams): {
-  reset: () => void;
-  abort: () => Promise<void>;
-  resume: (toolCallId: string, payload: unknown) => void;
-};
-//#endregion
-export { AddToolResultCommand, AssistantTransportState, ToolExecutionStatus, useToolInvocations };
-//# sourceMappingURL=useToolInvocations.d.ts.map

package/dist/react/runtimes/useToolInvocations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useToolInvocations.d.ts","names":[],"sources":["../../../src/react/runtimes/useToolInvocations.ts"],"mappings":";;;;;KAkBY,uBAAA;EAAA,SACD,QAAA,WAAmB,aAAA;EAAA,SACnB,KAAA,GAAQ,iBAAiB;EAAA,SACzB,SAAA;AAAA;AAAA,KAGC,oBAAA;EAAA,SACD,IAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA,EAAQ,iBAAA;EAAA,SACR,OAAA;EAAA,SACA,QAAA,GAAW,iBAAA;EAAA,SACX,YAAA,YAAwB,oBAAA;AAAA;AAAA,KA2B9B,wBAAA;EACH,KAAA,EAAO,uBAAA;EACP,QAAA,QAAgB,MAAA,SAAe,IAAA;EAC/B,QAAA,GAAW,OAAA,EAAS,oBAAA;EACpB,eAAA,GACE,OAAA,EACI,MAAA,SAAe,mBAAA,MAEb,IAAA,EAAM,MAAA,SAAe,mBAAA,MAClB,MAAA,SAAe,mBAAA;AAAA;;;;;;;KAUhB,mBAAA;EA/CD,wDAkDL,IAAA;AAAA;EAjD6B,uEAqD7B,IAAA,eArDiD;EAuDjD,OAAA;IAAW,IAAA;IAAe,OAAA;EAAA;AAAA;AAAA,iBAyChB,kBAAA,CAAA;EACd,KAAA;EACA,QAAA;EACA,QAAA;EACA;AAAA,GACC,wBAAA;;eA+fiB,OAAA;+BAkCW,OAAA;AAAA"}