@assistant-ui/core 0.2.23 → 0.3.1

package/src/react/runtimes/createRuntimeExtras.test.ts

@@ -6,7 +6,7 @@ type Extras = { value: number; greet: () => string };
 
 const clientWith = (extras: unknown) =>
   ({
-    thread: () => ({ getState: () => ({ extras }) }),
+    thread: { getState: () => ({ extras }) },
   }) as unknown as AssistantClient;
 
 describe("createRuntimeExtras", () => {

package/src/react/runtimes/createRuntimeExtras.ts

@@ -46,7 +46,7 @@ export const createRuntimeExtras = <T extends object>(
     is(extras) ? extras : undefined;
 
   const get = (client: AssistantClient): T =>
-    assert(client.thread().getState().extras);
+    assert(client.thread.getState().extras);
 
   function use<S>(
     select?: (extras: T) => S,

package/src/react/types/scopes/tools.ts

@@ -20,12 +20,6 @@ export type ToolsState = {
   /** Registered tool UIs (renderer + presentation options) keyed by tool name. */
   toolUIs: Record<string, readonly ToolRegistration[]>;
   mcpApp?: McpAppResourceOutput | undefined;
-  /**
-   * @deprecated Use {@link toolUIs} instead, whose entries carry the renderer
-   * alongside its presentation options. This component-only map is kept for
-   * back-compat and will be removed in v0.15.
-   */
-  tools: Record<string, ToolCallMessagePartComponent[]>;
 };
 
 export type ToolsMethods = {

package/src/react/utils/groupParts.ts

@@ -47,10 +47,8 @@ export const GROUPBY_MEMO_KEY: unique symbol = Symbol.for(
  *   `display: "standalone"`). Resolving the registry-driven cases reads the
  *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence
  *   over the `"tool-call"` entry.
- * - `"mcp-app"` — **deprecated**, kept for back-compat. Matches only MCP-app
- *   tool calls. Prefer `"standalone-tool-call"`, which is a superset.
  */
-type GroupPartType = PartState["type"] | "standalone-tool-call" | "mcp-app";
+type GroupPartType = PartState["type"] | "standalone-tool-call";
 
 /**
  * Build a `groupBy` from a `part.type → group-key path` lookup.
@@ -93,10 +91,6 @@ export const groupPartByType = <TKey extends `group-${string}`>(
       if (isStandalone && lookup["standalone-tool-call"] !== undefined) {
         return lookup["standalone-tool-call"]!;
       }
-      // TODO(v0.15): drop the deprecated "mcp-app" key (superseded by "standalone-tool-call").
-      if (isMcpApp && lookup["mcp-app"] !== undefined) {
-        return lookup["mcp-app"]!;
-      }
     }
     return lookup[part.type] ?? [];
   }) as ((part: PartState, context?: GroupByContext) => readonly TKey[]) & {

package/src/runtimes/local/local-thread-runtime-core.test.ts

@@ -497,6 +497,44 @@ describe("LocalThreadRuntimeCore tool approvals", () => {
 });
 
 describe("LocalThreadRuntimeCore cancellation", () => {
+  it("keeps a replacement run cancellable after the previous run settles", async () => {
+    let releaseFirst!: () => void;
+    let releaseSecond!: () => void;
+    const firstGate = new Promise<void>((resolve) => {
+      releaseFirst = resolve;
+    });
+    const secondGate = new Promise<void>((resolve) => {
+      releaseSecond = resolve;
+    });
+    const signals: AbortSignal[] = [];
+    const thread = createThread({
+      async *run({ abortSignal }) {
+        signals.push(abortSignal);
+        await (signals.length === 1 ? firstGate : secondGate);
+      },
+    });
+
+    const firstAppend = thread.append(userMessage("first"));
+    await flush();
+    const secondAppend = thread.append(userMessage("second"));
+    await flush();
+
+    expect(signals).toHaveLength(2);
+    expect(signals[0]?.aborted).toBe(true);
+    expect(signals[1]?.aborted).toBe(false);
+
+    releaseFirst();
+    await firstAppend;
+
+    thread.cancelRun();
+    const replacementWasAborted = signals[1]?.aborted;
+
+    releaseSecond();
+    await secondAppend;
+
+    expect(replacementWasAborted).toBe(true);
+  });
+
   it("marks the message cancelled when a streaming adapter returns after abort", async () => {
     let released!: () => void;
     const streaming = new Promise<void>((resolve) => {

package/src/runtimes/local/local-thread-runtime-core.ts

@@ -459,7 +459,8 @@ export class LocalThreadRuntimeCore
 
     // abort existing run
     this.abortController?.abort();
-    this.abortController = new AbortController();
+    const abortController = new AbortController();
+    this.abortController = abortController;
 
     const initialContent = message.content;
     const initialAnnotations = message.metadata?.unstable_annotations;
@@ -550,7 +551,7 @@ export class LocalThreadRuntimeCore
         runCallback ??
         this.adapters.chatModel.run.bind(this.adapters.chatModel);
 
-      const abortSignal = this.abortController.signal;
+      const abortSignal = abortController.signal;
       const threadId = this._getThreadId?.();
       const promiseOrGenerator = runCallback({
         messages,
@@ -609,7 +610,9 @@ export class LocalThreadRuntimeCore
         throw e;
       }
     } finally {
-      this.abortController = null;
+      if (this.abortController === abortController) {
+        this.abortController = null;
+      }
 
       const history = this._options.adapters.history;
       const item = {

package/src/store/clients/runtime-adapter.ts

@@ -13,17 +13,17 @@ export const baseRuntimeAdapterTransformScopes = (
   scopes.thread ??= Derived({
     source: "threads",
     query: { type: "main" },
-    get: (aui) => aui.threads().thread("main"),
+    get: (aui) => aui.threads.thread("main"),
   });
   scopes.threadListItem ??= Derived({
     source: "threads",
     query: { type: "main" },
-    get: (aui) => aui.threads().item("main"),
+    get: (aui) => aui.threads.item("main"),
   });
   scopes.composer ??= Derived({
     source: "thread",
     query: {},
-    get: (aui) => aui.threads().thread("main").composer(),
+    get: (aui) => aui.threads.thread("main").composer(),
   });
 
   if (!scopes.modelContext && parent.modelContext.source === null) {

package/src/tests/groupParts.test.ts

@@ -119,25 +119,7 @@ describe("groupPartByType", () => {
     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", () => {
+  it("falls back to 'tool-call' for MCP-app parts when 'standalone-tool-call' is absent", () => {
     const fn = groupPartByType({ "tool-call": ["group-tool"] });
     const mcpApp = part({
       type: "tool-call",
@@ -147,10 +129,10 @@ describe("groupPartByType", () => {
     expect(fn(mcpApp)).toEqual(["group-tool"]);
   });
 
-  it("does not route non-`ui://` tool calls through 'mcp-app'", () => {
+  it("does not treat non-`ui://` tool calls as standalone", () => {
     const fn = groupPartByType({
       "tool-call": ["group-tool"],
-      "mcp-app": ["group-mcp"],
+      "standalone-tool-call": ["group-standalone"],
     });
     const notMcp = part({
       type: "tool-call",
@@ -235,33 +217,6 @@ describe("groupPartByType", () => {
     expect(fn(mcpApp)).toEqual([]);
   });
 
-  it("routes MCP-app parts through the deprecated 'mcp-app' entry", () => {
-    const fn = groupPartByType({
-      "tool-call": ["group-tool"],
-      "mcp-app": ["group-mcp"],
-    });
-    const mcpApp = part({
-      type: "tool-call",
-      toolName: "render",
-      mcp: { app: { resourceUri: "ui://my-app" } },
-    } as Partial<PartState>);
-    expect(fn(mcpApp)).toEqual(["group-mcp"]);
-  });
-
-  it("prefers 'standalone-tool-call' over the deprecated 'mcp-app' entry", () => {
-    const fn = groupPartByType({
-      "tool-call": ["group-tool"],
-      "standalone-tool-call": ["group-standalone"],
-      "mcp-app": ["group-mcp"],
-    });
-    const mcpApp = part({
-      type: "tool-call",
-      toolName: "render",
-      mcp: { app: { resourceUri: "ui://x" } },
-    } as Partial<PartState>);
-    expect(fn(mcpApp)).toEqual(["group-standalone"]);
-  });
-
   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 })[