@assistant-ui/core 0.3.20 → 0.3.21

package/src/tests/external-thread-isLast.test.tsx

@@ -0,0 +1,69 @@
+// @vitest-environment jsdom
+
+import { render } from "@testing-library/react";
+import type { FC } from "react";
+import { describe, it, expect } from "vitest";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import {
+  ExternalThread,
+  type ExternalThreadProps,
+} from "../store/clients/external-thread";
+
+const renderThread = (props: ExternalThreadProps) => {
+  const captured: { aui?: ReturnType<typeof useAui> } = {};
+  const Capture: FC = () => {
+    captured.aui = useAui();
+    return null;
+  };
+  const App: FC<{ threadProps: ExternalThreadProps }> = ({ threadProps }) => {
+    const aui = useAui({ thread: ExternalThread(threadProps) });
+    return (
+      <AuiProvider value={aui}>
+        <Capture />
+      </AuiProvider>
+    );
+  };
+  const utils = render(<App threadProps={props} />);
+  return {
+    aui: () => captured.aui!,
+    rerender: (next: ExternalThreadProps) =>
+      utils.rerender(<App threadProps={next} />),
+  };
+};
+
+const userMessage = (id: string) =>
+  ({
+    id,
+    role: "user",
+    content: [{ type: "text", text: "hi" }],
+    createdAt: new Date(0),
+    metadata: { custom: {} },
+  }) as unknown as ExternalThreadProps["messages"][number];
+
+describe("ExternalThread isLast", () => {
+  const messages = [userMessage("m1"), userMessage("m2")];
+
+  it("agrees between the thread's message list and the message client", () => {
+    const t = renderThread({ messages });
+
+    expect(
+      t
+        .aui()
+        .thread.getState()
+        .messages.map((m) => m.isLast),
+    ).toEqual([false, true]);
+
+    expect(t.aui().thread.message({ index: 0 }).getState().isLast).toBe(false);
+    expect(t.aui().thread.message({ index: 1 }).getState().isLast).toBe(true);
+    expect(t.aui().thread.message({ id: "m2" }).getState().isLast).toBe(true);
+  });
+
+  it("moves to the new message when the thread grows", () => {
+    const t = renderThread({ messages });
+
+    t.rerender({ messages: [...messages, userMessage("m3")] });
+
+    expect(t.aui().thread.message({ id: "m2" }).getState().isLast).toBe(false);
+    expect(t.aui().thread.message({ id: "m3" }).getState().isLast).toBe(true);
+  });
+});

package/src/tests/get-thread-state-isRunning.test.ts

@@ -2,9 +2,9 @@ import { describe, expect, it } from "vitest";
 import { getThreadState } from "../runtime/api/thread-runtime";
 import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
 import type { ThreadMessage } from "../types/message";
-import type { ThreadListItemState } from "../runtime/api/thread-list-item-runtime";
+import type { ThreadListItemRuntimeState } from "../runtime/api/thread-list-item-runtime";
 
-const listItem = { id: "t1" } as unknown as ThreadListItemState;
+const listItem = { id: "t1" } as unknown as ThreadListItemRuntimeState;
 
 const baseRuntime = (
   overrides: Partial<ThreadRuntimeCore>,

package/src/tests/remote-thread-list-adapter-switch.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, onTestFinished, vi } from "vitest";
 import {
   createCore,
   deferred,
@@ -248,6 +248,50 @@ describe("RemoteThreadList adapter changes", () => {
     expect(stopped).not.toContain(core.mainThreadId);
   });
 
+  it("keeps stopping the threads missing from the replacement list when one stop throws", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({
+        threads: [thread("thread-a"), thread("thread-c")],
+      }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+    });
+    const core = createCore(adapterA);
+    const stopped: string[] = [];
+    const error = new Error("cleanup failed");
+    const hookManager = (
+      core as unknown as {
+        _hookManager: { stopThreadRuntime: (id: string) => void };
+      }
+    )._hookManager;
+    const originalStop = hookManager.stopThreadRuntime.bind(hookManager);
+    hookManager.stopThreadRuntime = (id: string) => {
+      stopped.push(id);
+      originalStop(id);
+      if (stopped.length === 1) throw error;
+    };
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    onTestFinished(() => consoleError.mockRestore());
+
+    await core.getLoadThreadsPromise();
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(stopped).toEqual(expect.arrayContaining(["thread-a", "thread-c"]));
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(core.getItemById("thread-b")).toBeDefined();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Thread runtime cleanup threw while stopping a thread",
+      error,
+    );
+  });
+
   it("does not reject when a controlled thread is missing from the replacement adapter", async () => {
     const adapterA = makeAdapter({
       list: async () => ({ threads: [thread("thread-a")] }),

package/src/types/message.ts

@@ -104,12 +104,14 @@ export type DataMessagePart<T = any> = {
  */
 export type GenerativeUINode =
   | string
+  | number
+  | readonly GenerativeUINode[]
   | {
       /** Allowlisted component name (resolved against the consumer registry). */
       readonly component: string;
       /** Props passed to the resolved component (must be JSON-serializable). */
       readonly props?: Record<string, unknown>;
-      /** Optional children — strings render as text, objects recurse. */
+      /** Optional child nodes — strings and numbers render as text; nested arrays and objects recurse. */
       readonly children?: readonly GenerativeUINode[];
       /** Optional stable key for React reconciliation. */
       readonly key?: string;
@@ -227,6 +229,38 @@ export type ToolApprovalResponse =
       readonly reason?: string;
     };
 
+/** One thing a user did in a tool call's rendered UI, stored with the call. */
+export type Unstable_ToolInteraction =
+  | {
+      /** A generative UI action the user fired, with the user's input under `$input`. */
+      readonly type: "action";
+      /** When the user acted, in epoch milliseconds. */
+      readonly occurredAt: number;
+      readonly payload: ReadonlyJSONObject;
+    }
+  | {
+      /** The answer the user gave to the tool's request for human input. */
+      readonly type: "human-response";
+      /** When the user answered, in epoch milliseconds. */
+      readonly occurredAt: number;
+      readonly payload: ReadonlyJSONValue;
+    };
+
+/**
+ * The interactions recorded on a tool call, oldest first. `omitted` counts
+ * earlier entries dropped to keep the log within its size limit.
+ */
+export type Unstable_ToolInteractionLog = {
+  readonly entries: readonly Unstable_ToolInteraction[];
+  readonly omitted?: number;
+};
+
+/** An interaction to record; the runtime validates the payload and stamps the time. */
+export type Unstable_ToolInteractionInput = {
+  readonly type: Unstable_ToolInteraction["type"];
+  readonly payload: unknown;
+};
+
 export type ToolCallMessagePart<
   TArgs = ReadonlyJSONObject,
   TResult = unknown,
@@ -243,10 +277,12 @@ export type ToolCallMessagePart<
    * `useToolArgsStatus` to detect which fields are still arriving.
    */
   readonly args: TArgs;
-  /** Result returned by the tool, if it has completed. */
+  /** Result returned by the tool. Final once it has completed; an interim value while `isPreliminary` is set. */
   readonly result?: TResult | undefined;
   /** Whether the result represents a tool execution error. */
   readonly isError?: boolean | undefined;
+  /** Whether `result` is an interim value from a tool that is still running, so the call is not settled yet. */
+  readonly isPreliminary?: boolean | undefined;
   /** Raw JSON argument text streamed by the model. */
   readonly argsText: string;
   /** UI-only artifact associated with the tool result. */
@@ -274,6 +310,12 @@ export type ToolCallMessagePart<
     readonly display?: ToolApprovalDisplay;
     /** Whether a free-form answer is accepted alongside the options. */
     readonly allowFreeform?: boolean;
+    /**
+     * Whether the request accepts a dismissal: `approved: false` with no
+     * answer. A decision is always refusable; a question is only when its host
+     * records a dismissal, so a renderer offers one only when this is set.
+     */
+    readonly dismissible?: boolean;
     readonly approved?: boolean;
     readonly reason?: string;
     readonly isAutomatic?: boolean;
@@ -293,6 +335,11 @@ export type ToolCallMessagePart<
    * conversation.
    */
   readonly messages?: readonly ThreadMessage[];
+  /**
+   * What the user did in this call's rendered UI, recorded so a stored
+   * conversation shows the answer beside the question.
+   */
+  readonly unstable_interactions?: Unstable_ToolInteractionLog;
 };
 
 export type ThreadUserMessagePart =

package/src/utils/normalizePartStatus.ts

@@ -4,6 +4,7 @@ import type {
   ThreadAssistantMessagePart,
   ThreadMessage,
   ThreadUserMessagePart,
+  ToolCallMessagePart,
   ToolCallMessagePartStatus,
 } from "../types/message";
 
@@ -56,6 +57,14 @@ export const normalizePartStatus = (
   return INCOMPLETE_STATUSES[normalizedReason];
 };
 
+export const hasPendingToolAction = (
+  part: Pick<ToolCallMessagePart, "approval" | "interrupt">,
+): boolean =>
+  part.interrupt != null ||
+  (part.approval != null &&
+    part.approval.approved === undefined &&
+    part.approval.resolution === undefined);
+
 export const toMessagePartStatus = (
   message: ThreadMessage,
   partIndex: number,
@@ -64,7 +73,11 @@ export const toMessagePartStatus = (
   if (message.role !== "assistant") return COMPLETE_STATUS;
 
   if (part.type === "tool-call") {
-    if (part.result === undefined) {
+    if (
+      part.result === undefined ||
+      part.isPreliminary ||
+      hasPendingToolAction(part)
+    ) {
       return message.status;
     } else {
       return COMPLETE_STATUS;

package/dist/tests/remote-thread-list-test-helpers.d.ts

@@ -1,15 +0,0 @@
-import { ModelContextProvider } from "../model-context/types.js";
-import { RemoteThreadListAdapter } from "../runtimes/remote-thread-list/types.js";
-import { RemoteThreadListThreadListRuntimeCore } from "../react/runtimes/RemoteThreadListThreadListRuntimeCore.js";
-//#region src/tests/remote-thread-list-test-helpers.d.ts
-export declare function deferred<T>(): {
-  promise: Promise<T>;
-  resolve: (value: T) => void;
-  reject: (reason?: unknown) => void;
-};
-export declare const contextProvider: ModelContextProvider;
-export declare function setStartThreadRuntime(core: RemoteThreadListThreadListRuntimeCore, startThreadRuntime: (id: string) => Promise<unknown>): void;
-export declare function makeAdapter(overrides?: Partial<RemoteThreadListAdapter>): RemoteThreadListAdapter;
-export declare function createCore(adapter: RemoteThreadListAdapter, threadId?: string, onThreadIdChange?: (threadId: string | undefined) => void): RemoteThreadListThreadListRuntimeCore;
-//#endregion
-//# sourceMappingURL=remote-thread-list-test-helpers.d.ts.map

package/dist/tests/remote-thread-list-test-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"remote-thread-list-test-helpers.d.ts","names":[],"sources":["../../src/tests/remote-thread-list-test-helpers.ts"],"mappings":";;;;wBAKgB,SAAS;;EACD,UAAA,OAAA;EACC,SAAA;;qBAQZ,iBAAiB;wBAKd,sBACd,MAAM,uCACN,qBAAqB,eAAe;wBAWtB,YACd,YAAW,QAAQ,2BAClB;wBA6Ba,WACd,SAAS,yBACT,mBACA,oBAAoB,wCACnB"}

package/dist/tests/remote-thread-list-test-helpers.js

@@ -1,59 +0,0 @@
-import { RemoteThreadListThreadListRuntimeCore } from "../react/runtimes/RemoteThreadListThreadListRuntimeCore.js";
-import { vi } from "vitest";
-//#region src/tests/remote-thread-list-test-helpers.ts
-function deferred() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((res, rej) => {
-			resolve = res;
-			reject = rej;
-		}),
-		resolve,
-		reject
-	};
-}
-const contextProvider = {
-	getModelContext: () => ({}),
-	subscribe: () => () => {}
-};
-function setStartThreadRuntime(core, startThreadRuntime) {
-	core._hookManager.startThreadRuntime = startThreadRuntime;
-}
-function makeAdapter(overrides = {}) {
-	return {
-		list: vi.fn(async () => ({ threads: [] })),
-		initialize: vi.fn(async (threadId) => ({
-			remoteId: threadId,
-			externalId: threadId
-		})),
-		rename: vi.fn(async () => {}),
-		archive: vi.fn(async () => {}),
-		unarchive: vi.fn(async () => {}),
-		delete: vi.fn(async () => {}),
-		generateTitle: vi.fn(async () => new ReadableStream({ start(c) {
-			c.close();
-		} })),
-		fetch: vi.fn(async (id) => ({
-			status: "regular",
-			remoteId: id,
-			externalId: id,
-			title: "Test"
-		})),
-		...overrides
-	};
-}
-function createCore(adapter, threadId, onThreadIdChange) {
-	const core = new RemoteThreadListThreadListRuntimeCore({
-		adapter,
-		runtimeHook: () => ({}),
-		threadId,
-		onThreadIdChange
-	}, contextProvider);
-	setStartThreadRuntime(core, async () => ({}));
-	return core;
-}
-//#endregion
-export { contextProvider, createCore, deferred, makeAdapter, setStartThreadRuntime };
-
-//# sourceMappingURL=remote-thread-list-test-helpers.js.map

package/dist/tests/remote-thread-list-test-helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"remote-thread-list-test-helpers.js","names":["vi","RemoteThreadListThreadListRuntimeCore","RemoteThreadListAdapter","ModelContextProvider","deferred","resolve","value","T","reject","reason","promise","Promise","res","rej","contextProvider","getModelContext","subscribe","setStartThreadRuntime","core","startThreadRuntime","id","_hookManager","makeAdapter","overrides","Partial","list","fn","threads","initialize","threadId","remoteId","externalId","rename","archive","unarchive","delete","generateTitle","ReadableStream","start","c","close","fetch","status","const","title","createCore","adapter","onThreadIdChange","runtimeHook"],"sources":["../../src/tests/remote-thread-list-test-helpers.ts"],"sourcesContent":["import { vi } from \"vitest\";\nimport { RemoteThreadListThreadListRuntimeCore } from \"../react/runtimes/RemoteThreadListThreadListRuntimeCore\";\nimport type { RemoteThreadListAdapter } from \"../runtimes/remote-thread-list/types\";\nimport type { ModelContextProvider } from \"../model-context/types\";\n\nexport function deferred<T>() {\n  let resolve!: (value: T) => void;\n  let reject!: (reason?: unknown) => void;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  return { promise, resolve, reject };\n}\n\nexport const contextProvider: ModelContextProvider = {\n  getModelContext: () => ({}),\n  subscribe: () => () => {},\n};\n\nexport function setStartThreadRuntime(\n  core: RemoteThreadListThreadListRuntimeCore,\n  startThreadRuntime: (id: string) => Promise<unknown>,\n) {\n  (\n    core as unknown as {\n      _hookManager: {\n        startThreadRuntime: (id: string) => Promise<unknown>;\n      };\n    }\n  )._hookManager.startThreadRuntime = startThreadRuntime;\n}\n\nexport function makeAdapter(\n  overrides: Partial<RemoteThreadListAdapter> = {},\n): RemoteThreadListAdapter {\n  return {\n    list: vi.fn(async () => ({ threads: [] })),\n    initialize: vi.fn(async (threadId: string) => ({\n      remoteId: threadId,\n      externalId: threadId,\n    })),\n    rename: vi.fn(async () => {}),\n    archive: vi.fn(async () => {}),\n    unarchive: vi.fn(async () => {}),\n    delete: vi.fn(async () => {}),\n    generateTitle: vi.fn(\n      async () =>\n        new ReadableStream({\n          start(c) {\n            c.close();\n          },\n        }) as never,\n    ),\n    fetch: vi.fn(async (id: string) => ({\n      status: \"regular\" as const,\n      remoteId: id,\n      externalId: id,\n      title: \"Test\",\n    })),\n    ...overrides,\n  };\n}\n\nexport function createCore(\n  adapter: RemoteThreadListAdapter,\n  threadId?: string,\n  onThreadIdChange?: (threadId: string | undefined) => void,\n): RemoteThreadListThreadListRuntimeCore {\n  const core = new RemoteThreadListThreadListRuntimeCore(\n    { adapter, runtimeHook: () => ({}) as never, threadId, onThreadIdChange },\n    contextProvider,\n  );\n  // `startThreadRuntime` blocks until a React component attaches a runtime;\n  // stub it so non-React unit tests don't hang.\n  setStartThreadRuntime(core, async () => ({}));\n  return core;\n}\n"],"mappings":";;;AAKA,SAAgBI,WAAc;CAC5B,IAAIC;CACJ,IAAIG;CAKJ,OAAO;EAAEE,SAAAA,IAJWC,SAAYC,KAAKC,QAAQ;GAC3CR,UAAUO;GACVJ,SAASK;EACX,CACSH;EAASL;EAASG;CAAO;AACpC;AAEA,MAAaM,kBAAwC;CACnDC,wBAAwB,CAAC;CACzBC,uBAAuB,CAAC;AAC1B;AAEA,SAAgBC,sBACdC,MACAC,oBACA;CACA,KAMEE,aAAaF,qBAAqBA;AACtC;AAEA,SAAgBG,YACdC,YAA8C,CAAC,GACtB;CACzB,OAAO;EACLE,MAAMzB,GAAG0B,GAAG,aAAa,EAAEC,SAAS,CAAA,EAAG,EAAE;EACzCC,YAAY5B,GAAG0B,GAAG,OAAOG,cAAsB;GAC7CC,UAAUD;GACVE,YAAYF;EACd,EAAE;EACFG,QAAQhC,GAAG0B,GAAG,YAAY,CAAC,CAAC;EAC5BO,SAASjC,GAAG0B,GAAG,YAAY,CAAC,CAAC;EAC7BQ,WAAWlC,GAAG0B,GAAG,YAAY,CAAC,CAAC;EAC/BS,QAAQnC,GAAG0B,GAAG,YAAY,CAAC,CAAC;EAC5BU,eAAepC,GAAG0B,GAChB,YACE,IAAIW,eAAe,EACjBC,MAAMC,GAAG;GACPA,EAAEC,MAAM;EACV,EACF,CAAC,CACL;EACAC,OAAOzC,GAAG0B,GAAG,OAAON,QAAgB;GAClCsB,QAAQ;GACRZ,UAAUV;GACVW,YAAYX;GACZwB,OAAO;EACT,EAAE;EACF,GAAGrB;CACL;AACF;AAEA,SAAgBsB,WACdC,SACAjB,UACAkB,kBACuC;CACvC,MAAM7B,OAAO,IAAIjB,sCACf;EAAE6C;EAASE,oBAAoB,CAAC;EAAanB;EAAUkB;CAAiB,GACxEjC,eACF;CAGAG,sBAAsBC,MAAM,aAAa,CAAC,EAAE;CAC5C,OAAOA;AACT"}