@assistant-ui/core 0.3.6 → 0.3.8

package/src/tests/auiV0Encode.test.ts

@@ -236,6 +236,33 @@ describe("auiV0Encode", () => {
     ]);
   });
 
+  it("preserves reasoning summaries and omits absent summaries", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "reasoning", text: "thinking", unstable_summary: "Planning" },
+        { type: "reasoning", text: "more thinking", unstable_summary: "" },
+        { type: "reasoning", text: "no summary" },
+      ],
+    });
+
+    expect(encoded.content).toEqual([
+      { type: "reasoning", text: "thinking", unstable_summary: "Planning" },
+      { type: "reasoning", text: "more thinking", unstable_summary: "" },
+      { type: "reasoning", text: "no summary" },
+    ]);
+  });
+
   it("drops per-part status from attachment content in the core cloud encoder", () => {
     const encoded = auiV0Encode({
       id: "m1",
@@ -306,6 +333,76 @@ describe("auiV0Encode", () => {
 });
 
 describe("auiV0Decode", () => {
+  it("round-trips a reasoning summary", () => {
+    const encoded = auiV0Encode({
+      id: "local",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "reasoning", text: "thinking", unstable_summary: "Planning" },
+      ],
+    });
+
+    const { message } = auiV0Decode({
+      id: "cloud",
+      parent_id: null,
+      format: "aui/v0",
+      content: encoded,
+      created_at: new Date("2026-03-15T00:00:00.000Z"),
+    } as unknown as Parameters<typeof auiV0Decode>[0]);
+
+    expect(message.content).toEqual([
+      { type: "reasoning", text: "thinking", unstable_summary: "Planning" },
+    ]);
+  });
+
+  it("round-trips a reasoning summary without text", () => {
+    const encoded = auiV0Encode({
+      id: "local",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        {
+          type: "reasoning",
+          text: "",
+          unstable_summary: "Searching the codebase",
+        },
+      ],
+    });
+
+    const { message } = auiV0Decode({
+      id: "cloud",
+      parent_id: null,
+      format: "aui/v0",
+      content: encoded,
+      created_at: new Date("2026-03-15T00:00:00.000Z"),
+    } as unknown as Parameters<typeof auiV0Decode>[0]);
+
+    expect(message.content).toEqual([
+      {
+        type: "reasoning",
+        text: "",
+        unstable_summary: "Searching the codebase",
+      },
+    ]);
+  });
+
   it("round-trips a pending tool-call approval so a paused run stays resumable", () => {
     const content = auiV0Encode({
       id: "local",

package/src/tests/default-edit-composer-runtime-core.test.ts

@@ -132,7 +132,7 @@ describe("DefaultEditComposerRuntimeCore", () => {
   });
 
   describe("send behavior", () => {
-    it("does not call append when nothing changed", async () => {
+    it("calls append even when nothing changed, branching with the same message", async () => {
       const { runtime, append } = makeRuntime();
       const composer = new DefaultEditComposerRuntimeCore(runtime, () => {}, {
         parentId: "p1",
@@ -141,7 +141,11 @@ describe("DefaultEditComposerRuntimeCore", () => {
         }),
       });
       await composer.send();
-      expect(append).not.toHaveBeenCalled();
+      expect(append).toHaveBeenCalledTimes(1);
+      const appended = append.mock.calls[0]![0] as AppendMessage;
+      expect(appended.content).toEqual([{ type: "text", text: "same" }]);
+      expect(appended.parentId).toBe("p1");
+      expect(appended.sourceId).toBe("msg-1");
     });
 
     it("calls append when text changes", async () => {

package/src/tests/framework-neutral-boundary.test.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { describe, expect, it } from "vitest";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 
 const SRC_DIR = resolve(__dirname, "..");
@@ -108,19 +108,6 @@ function walkFrom(entry: string): { forbidden: string[]; jsxFiles: string[] } {
   return { forbidden, jsxFiles };
 }
 
-function findFiles(dir: string, ext: string[]): string[] {
-  const results: string[] = [];
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    if (statSync(full).isDirectory()) {
-      results.push(...findFiles(full, ext));
-    } else if (ext.some((e) => full.endsWith(e))) {
-      results.push(full);
-    }
-  }
-  return results;
-}
-
 function nonTypeImportNames(clause: string): string[] {
   const names: string[] = [];
   const trimmed = clause.trim();
@@ -183,15 +170,60 @@ describe("framework neutral boundary", () => {
     ).toEqual([]);
   });
 
-  it("src/store may only pull react names the tap shim dispatches", () => {
-    const storeDir = resolve(SRC_DIR, "store");
-    const files = findFiles(storeDir, [".ts"]).filter(
-      (f) => !f.includes(".test."),
-    );
+  it("the store entry graphs stay hostable inside a tap root", () => {
     const violations: string[] = [];
+    const jsxFiles: string[] = [];
+    const visited = new Set<string>();
+    const pending = [
+      resolve(SRC_DIR, "store/index.ts"),
+      resolve(SRC_DIR, "store/internal.ts"),
+    ];
+
+    // Walks the runtime graph only: type-only imports are erased at build, so
+    // they neither carry runtime dependencies nor get traversed. This is also
+    // why type imports may keep using the @assistant-ui/store barrel: the
+    // augmentations target that specifier, and splitting types across entries
+    // would fork the ScopeRegistry seen by src-mapped consumers.
+    const RUNTIME_IMPORT_RE =
+      /(?:^|\n)\s*(?:import|export)\s+(?!type\b)(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\*|\w+(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+))?)\s+from\s+)?["']([^"']+)["']/g;
+
+    const collectRuntimeImports = (content: string): string[] => {
+      const specs: string[] = [];
+      for (const re of [RUNTIME_IMPORT_RE, DYNAMIC_IMPORT_RE]) {
+        re.lastIndex = 0;
+        let match: RegExpExecArray | null;
+        while ((match = re.exec(content)) !== null) {
+          specs.push(match[1]!);
+        }
+      }
+      return specs;
+    };
+
+    while (pending.length > 0) {
+      const file = pending.pop()!;
+      if (visited.has(file)) continue;
+      visited.add(file);
+      if (file.endsWith(".tsx")) jsxFiles.push(relative(SRC_DIR, file));
 
-    for (const file of files) {
       const content = readFileSync(file, "utf-8");
+
+      for (const spec of collectRuntimeImports(content)) {
+        if (spec === "react/jsx-runtime") {
+          violations.push(
+            `${relative(SRC_DIR, file)} imports "react/jsx-runtime"`,
+          );
+        }
+        if (spec === "@assistant-ui/store") {
+          violations.push(
+            `${relative(SRC_DIR, file)} value-imports the "@assistant-ui/store" barrel; use "@assistant-ui/store/client"`,
+          );
+        }
+        const resolved = resolveRelative(file, spec);
+        if (resolved && !visited.has(resolved)) {
+          pending.push(resolved);
+        }
+      }
+
       FROM_REACT_RE.lastIndex = 0;
       let match: RegExpExecArray | null;
       while ((match = FROM_REACT_RE.exec(content)) !== null) {
@@ -210,12 +242,16 @@ describe("framework neutral boundary", () => {
 
     expect(
       violations,
-      `src/store may only use react names the tap shim dispatches ` +
-        `(useState, useReducer, useRef, useMemo, useCallback, useEffect, useLayoutEffect, ` +
-        `useInsertionEffect, useEffectEvent, useSyncExternalStore, useDebugValue, use, ` +
-        `useContext, createContext).\n` +
+      `The store entry graphs run inside tap roots on every framework, so they may ` +
+        `only use react names the tap shim dispatches, never react/jsx-runtime, and ` +
+        `never the @assistant-ui/store barrel (whose module scope requires React).\n` +
         `Violations:\n` +
         violations.map((f) => `  - ${f}`).join("\n"),
     ).toEqual([]);
+    expect(
+      jsxFiles,
+      `The JSX transform injects react/jsx-runtime at build time, so the store entry graphs must not contain .tsx files:\n` +
+        jsxFiles.map((f) => `  - ${f}`).join("\n"),
+    ).toEqual([]);
   });
 });

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

@@ -147,6 +147,49 @@ describe("fromThreadMessageLike", () => {
       expect(result.content).toEqual([{ type: "reasoning", text: "hi" }]);
     });
 
+    it("keeps a reasoning part with a summary and no text", () => {
+      const result = fromThreadMessageLike(
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "reasoning",
+              text: "",
+              unstable_summary: "Searching the codebase",
+            },
+          ],
+        },
+        fallbackId,
+        fallbackStatus,
+      );
+
+      expect(result.content).toEqual([
+        {
+          type: "reasoning",
+          text: "",
+          unstable_summary: "Searching the codebase",
+        },
+      ]);
+    });
+
+    it("drops a reasoning part with neither text nor a summary to show", () => {
+      // the transport layers round-trip an empty summary faithfully; this is
+      // the display normalizer, so it drops a part with nothing to render for
+      // the same reason it drops whitespace-only text.
+      const message = fromThreadMessageLike(
+        {
+          role: "assistant",
+          content: [
+            { type: "reasoning", text: "", unstable_summary: "" },
+            { type: "reasoning", text: "  ", unstable_summary: "   " },
+          ],
+        },
+        "m1",
+        { type: "complete", reason: "unknown" },
+      );
+
+      expect(message.content).toEqual([]);
+    });
     it("drops an assistant image part whose image is undefined", () => {
       const result = fromThreadMessageLike(
         {

package/src/types/message.ts

@@ -23,6 +23,7 @@ export type ReasoningMessagePart = {
   readonly type: "reasoning";
   readonly text: string;
   readonly status?: MessagePartStreamStatus;
+  readonly unstable_summary?: string;
   readonly providerMetadata?: PartProviderMetadata;
   readonly parentId?: string;
 };