@assistant-ui/core 0.3.1 → 0.3.3

package/dist/utils/getGroupStatus.d.ts

@@ -0,0 +1,9 @@
+import { MessagePartStatus, ToolCallMessagePartStatus } from "../types/message.js";
+//#region src/utils/getGroupStatus.d.ts
+type PartWithStatus = {
+  readonly status: MessagePartStatus | ToolCallMessagePartStatus;
+};
+declare const getGroupStatus: (parts: readonly (PartWithStatus | undefined)[], indices?: readonly number[]) => MessagePartStatus | ToolCallMessagePartStatus;
+//#endregion
+export { getGroupStatus };
+//# sourceMappingURL=getGroupStatus.d.ts.map

package/dist/utils/getGroupStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGroupStatus.d.ts","names":[],"sources":["../../src/utils/getGroupStatus.ts"],"mappings":";;KAMK;WACM,QAAQ,oBAAoB;;cAG1B,iBACX,iBAAiB,+BACjB,gCACC,oBAAoB"}

package/dist/utils/getGroupStatus.js

@@ -0,0 +1,15 @@
+import { COMPLETE_STATUS, RUNNING_STATUS } from "./normalizePartStatus.js";
+//#region src/utils/getGroupStatus.ts
+const getGroupStatus = (parts, indices) => {
+	if (indices) {
+		for (const index of indices) if (parts[index]?.status.type === "running") return RUNNING_STATUS;
+		const lastIndex = indices.at(-1);
+		return lastIndex === void 0 ? COMPLETE_STATUS : parts[lastIndex]?.status ?? COMPLETE_STATUS;
+	}
+	for (const part of parts) if (part?.status.type === "running") return RUNNING_STATUS;
+	return parts.at(-1)?.status ?? COMPLETE_STATUS;
+};
+//#endregion
+export { getGroupStatus };
+
+//# sourceMappingURL=getGroupStatus.js.map

package/dist/utils/getGroupStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGroupStatus.js","names":["MessagePartStatus","ToolCallMessagePartStatus","COMPLETE_STATUS","RUNNING_STATUS","PartWithStatus","status","getGroupStatus","parts","indices","index","type","lastIndex","at","undefined","part"],"sources":["../../src/utils/getGroupStatus.ts"],"sourcesContent":["import type {\n  MessagePartStatus,\n  ToolCallMessagePartStatus,\n} from \"../types/message\";\nimport { COMPLETE_STATUS, RUNNING_STATUS } from \"./normalizePartStatus\";\n\ntype PartWithStatus = {\n  readonly status: MessagePartStatus | ToolCallMessagePartStatus;\n};\n\nexport const getGroupStatus = (\n  parts: readonly (PartWithStatus | undefined)[],\n  indices?: readonly number[],\n): MessagePartStatus | ToolCallMessagePartStatus => {\n  if (indices) {\n    for (const index of indices) {\n      if (parts[index]?.status.type === \"running\") return RUNNING_STATUS;\n    }\n\n    const lastIndex = indices.at(-1);\n    return lastIndex === undefined\n      ? COMPLETE_STATUS\n      : (parts[lastIndex]?.status ?? COMPLETE_STATUS);\n  }\n\n  for (const part of parts) {\n    if (part?.status.type === \"running\") return RUNNING_STATUS;\n  }\n\n  return parts.at(-1)?.status ?? COMPLETE_STATUS;\n};\n"],"mappings":";;AAUA,MAAaM,kBACXC,OACAC,YACkD;CAClD,IAAIA,SAAS;EACX,KAAK,MAAMC,SAASD,SAClB,IAAID,MAAME,MAAM,EAAEJ,OAAOK,SAAS,WAAW,OAAOP;EAGtD,MAAMQ,YAAYH,QAAQI,GAAG,EAAE;EAC/B,OAAOD,cAAcE,KAAAA,IACjBX,kBACCK,MAAMI,UAAU,EAAEN,UAAUH;CACnC;CAEA,KAAK,MAAMY,QAAQP,OACjB,IAAIO,MAAMT,OAAOK,SAAS,WAAW,OAAOP;CAG9C,OAAOI,MAAMK,GAAG,EAAE,CAAC,EAAEP,UAAUH;AACjC"}

package/dist/utils/normalizePartStatus.d.ts

@@ -0,0 +1,8 @@
+import { MessagePartStatus, ThreadAssistantMessagePart, ThreadUserMessagePart } from "../types/message.js";
+//#region src/utils/normalizePartStatus.d.ts
+declare const COMPLETE_STATUS: MessagePartStatus;
+declare const RUNNING_STATUS: MessagePartStatus;
+declare const normalizePartStatus: (part: ThreadUserMessagePart | ThreadAssistantMessagePart) => MessagePartStatus | undefined;
+//#endregion
+export { COMPLETE_STATUS, RUNNING_STATUS, normalizePartStatus };
+//# sourceMappingURL=normalizePartStatus.d.ts.map

package/dist/utils/normalizePartStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizePartStatus.d.ts","names":[],"sources":["../../src/utils/normalizePartStatus.ts"],"mappings":";;cAOa,iBAAiB;cAGjB,gBAAgB;cAoBhB,sBACX,MAAM,wBAAwB,+BAC7B"}

package/dist/utils/normalizePartStatus.js

@@ -0,0 +1,39 @@
+//#region src/utils/normalizePartStatus.ts
+const COMPLETE_STATUS = Object.freeze({ type: "complete" });
+const RUNNING_STATUS = Object.freeze({ type: "running" });
+const INCOMPLETE_STATUSES = Object.freeze({
+	cancelled: Object.freeze({
+		type: "incomplete",
+		reason: "cancelled"
+	}),
+	length: Object.freeze({
+		type: "incomplete",
+		reason: "length"
+	}),
+	"content-filter": Object.freeze({
+		type: "incomplete",
+		reason: "content-filter"
+	}),
+	other: Object.freeze({
+		type: "incomplete",
+		reason: "other"
+	}),
+	error: Object.freeze({
+		type: "incomplete",
+		reason: "error"
+	})
+});
+const normalizePartStatus = (part) => {
+	const status = part.status;
+	if (!status || typeof status !== "object") return void 0;
+	const { type } = status;
+	if (type === "running") return RUNNING_STATUS;
+	if (type === "complete") return COMPLETE_STATUS;
+	if (type !== "incomplete") return void 0;
+	const { reason } = status;
+	return INCOMPLETE_STATUSES[reason === "cancelled" || reason === "length" || reason === "content-filter" || reason === "other" || reason === "error" ? reason : "other"];
+};
+//#endregion
+export { COMPLETE_STATUS, RUNNING_STATUS, normalizePartStatus };
+
+//# sourceMappingURL=normalizePartStatus.js.map

package/dist/utils/normalizePartStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizePartStatus.js","names":["MessagePartStatus","MessagePartStreamStatus","ThreadAssistantMessagePart","ThreadUserMessagePart","COMPLETE_STATUS","Object","freeze","type","RUNNING_STATUS","IncompleteMessagePartStatus","Extract","INCOMPLETE_STATUSES","Readonly","Record","cancelled","reason","length","other","error","normalizePartStatus","part","status","undefined","normalizedReason"],"sources":["../../src/utils/normalizePartStatus.ts"],"sourcesContent":["import type {\n  MessagePartStatus,\n  MessagePartStreamStatus,\n  ThreadAssistantMessagePart,\n  ThreadUserMessagePart,\n} from \"../types/message\";\n\nexport const COMPLETE_STATUS: MessagePartStatus = Object.freeze({\n  type: \"complete\",\n});\nexport const RUNNING_STATUS: MessagePartStatus = Object.freeze({\n  type: \"running\",\n});\ntype IncompleteMessagePartStatus = Extract<\n  MessagePartStreamStatus,\n  { readonly type: \"incomplete\" }\n>;\nconst INCOMPLETE_STATUSES: Readonly<\n  Record<IncompleteMessagePartStatus[\"reason\"], IncompleteMessagePartStatus>\n> = Object.freeze({\n  cancelled: Object.freeze({ type: \"incomplete\", reason: \"cancelled\" }),\n  length: Object.freeze({ type: \"incomplete\", reason: \"length\" }),\n  \"content-filter\": Object.freeze({\n    type: \"incomplete\",\n    reason: \"content-filter\",\n  }),\n  other: Object.freeze({ type: \"incomplete\", reason: \"other\" }),\n  error: Object.freeze({ type: \"incomplete\", reason: \"error\" }),\n});\n\nexport const normalizePartStatus = (\n  part: ThreadUserMessagePart | ThreadAssistantMessagePart,\n): MessagePartStatus | undefined => {\n  const status = (part as { readonly status?: unknown }).status;\n  if (!status || typeof status !== \"object\") return undefined;\n\n  const { type } = status as { readonly type?: unknown };\n  if (type === \"running\") return RUNNING_STATUS;\n  if (type === \"complete\") return COMPLETE_STATUS;\n  if (type !== \"incomplete\") return undefined;\n\n  const { reason } = status as {\n    readonly reason?: unknown;\n  };\n  const normalizedReason: IncompleteMessagePartStatus[\"reason\"] =\n    reason === \"cancelled\" ||\n    reason === \"length\" ||\n    reason === \"content-filter\" ||\n    reason === \"other\" ||\n    reason === \"error\"\n      ? reason\n      : \"other\";\n\n  return INCOMPLETE_STATUSES[normalizedReason];\n};\n"],"mappings":";AAOA,MAAaI,kBAAqCC,OAAOC,OAAO,EAC9DC,MAAM,WACR,CAAC;AACD,MAAaC,iBAAoCH,OAAOC,OAAO,EAC7DC,MAAM,UACR,CAAC;AAKD,MAAMI,sBAEFN,OAAOC,OAAO;CAChBQ,WAAWT,OAAOC,OAAO;EAAEC,MAAM;EAAcQ,QAAQ;CAAY,CAAC;CACpEC,QAAQX,OAAOC,OAAO;EAAEC,MAAM;EAAcQ,QAAQ;CAAS,CAAC;CAC9D,kBAAkBV,OAAOC,OAAO;EAC9BC,MAAM;EACNQ,QAAQ;CACV,CAAC;CACDE,OAAOZ,OAAOC,OAAO;EAAEC,MAAM;EAAcQ,QAAQ;CAAQ,CAAC;CAC5DG,OAAOb,OAAOC,OAAO;EAAEC,MAAM;EAAcQ,QAAQ;CAAQ,CAAC;AAC9D,CAAC;AAED,MAAaI,uBACXC,SACkC;CAClC,MAAMC,SAAUD,KAAuCC;CACvD,IAAI,CAACA,UAAU,OAAOA,WAAW,UAAU,OAAOC,KAAAA;CAElD,MAAM,EAAEf,SAASc;CACjB,IAAId,SAAS,WAAW,OAAOC;CAC/B,IAAID,SAAS,YAAY,OAAOH;CAChC,IAAIG,SAAS,cAAc,OAAOe,KAAAA;CAElC,MAAM,EAAEP,WAAWM;CAYnB,OAAOV,oBARLI,WAAW,eACXA,WAAW,YACXA,WAAW,oBACXA,WAAW,WACXA,WAAW,UACPA,SACA;AAGR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -59,7 +59,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.30",
+    "assistant-stream": "^0.3.31",
     "nanoid": "^6.0.0"
   },
   "optionalDevDependencies": {
@@ -95,8 +95,8 @@
     "react-dom": "^19.2.8",
     "vitest": "^4.1.10",
     "zustand": "^5.0.14",
-    "@assistant-ui/store": "0.3.1",
-    "@assistant-ui/tap": "0.9.7",
+    "@assistant-ui/store": "0.3.2",
+    "@assistant-ui/tap": "0.9.9",
     "@assistant-ui/vite": "0.0.11",
     "@assistant-ui/x-buildutils": "0.0.20",
     "assistant-cloud": "0.1.37"

package/src/index.ts

@@ -34,6 +34,7 @@ export type {
   ThreadAssistantMessagePart,
   // Message status
   MessagePartStatus,
+  MessagePartStreamStatus,
   ToolCallMessagePartStatus,
   MessageStatus,
   // Thread messages

package/src/internal.ts

@@ -32,6 +32,7 @@ export {
 
 // Message utilities
 export { getThreadMessageText } from "./utils/text";
+export { toMessagePartStatus } from "./runtime/api/message-runtime";
 export { resolveToolApprovalResponse } from "./runtime/utils/resolveToolApprovalResponse";
 export { consumeSuggestionResult } from "./adapters/suggestion";
 
@@ -58,12 +59,5 @@ export { isJSONValue, isRecord } from "./utils/json/is-json";
 // outbound part conversion lives in one place.
 export { httpUrlPattern, parseDataUrl } from "./utils/data-url";
 
-// Runtime extras helper for external-store adapters. Internal because the
-// tap-native runtime path replaces the `thread.extras` side-channel it wraps.
-export {
-  createRuntimeExtras,
-  type RuntimeExtras,
-} from "./react/runtimes/createRuntimeExtras";
-
 export * from "./runtime/internal";
 export * from "./runtimes/internal";

package/src/react/AssistantProvider.tsx

@@ -19,24 +19,37 @@ export type AssistantProviderBaseProps = PropsWithChildren<{
   aui?: AssistantClient | null;
 }>;
 
+const AssistantProviderInner: FC<
+  PropsWithChildren<{ runtime: AssistantRuntime }>
+> = ({ runtime, children }) => {
+  // The runtime has a stable identity but mutates in place: its options are
+  // pushed in by an unconditional effect inside <RenderComponent />, so that
+  // element must be re-created every commit for React to re-render it and
+  // re-run the effect. React Compiler caches <RenderComponent /> on the
+  // stable RenderComponent type, which silences the effect and stops option
+  // changes (e.g. unstable_enableMessageQueue) from reaching the runtime.
+  "use no memo";
+  const aui = useAui({ threads: RuntimeAdapter(runtime) });
+  const RenderComponent = getRenderComponent(runtime);
+  return (
+    <AuiProvider value={aui}>
+      {RenderComponent && <RenderComponent />}
+      {children}
+    </AuiProvider>
+  );
+};
+
 export const AssistantProviderBase: FC<AssistantProviderBaseProps> = memo(
-  ({ runtime, aui: parent = null, children }) => {
-    // The runtime has a stable identity but mutates in place: its options are
-    // pushed in by an unconditional effect inside <RenderComponent />, so that
-    // element must be re-created every commit for React to re-render it and
-    // re-run the effect. React Compiler caches <RenderComponent /> on the
-    // stable RenderComponent type, which silences the effect and stops option
-    // changes (e.g. unstable_enableMessageQueue) from reaching the runtime.
-    "use no memo";
-    const aui = useAui({ threads: RuntimeAdapter(runtime) }, { parent });
-    const RenderComponent = getRenderComponent(runtime);
+  ({ runtime, aui = null, children }) => {
     const inner = (
-      <AuiProvider value={aui}>
-        {RenderComponent && <RenderComponent />}
+      <AssistantProviderInner runtime={runtime}>
         {children}
-      </AuiProvider>
+      </AssistantProviderInner>
+    );
+    return aui ? (
+      <AuiProvider value={aui}>{inner}</AuiProvider>
+    ) : (
+      <AuiProvider value={null}>{inner}</AuiProvider>
     );
-    if (!parent) return inner;
-    return <AuiProvider value={parent}>{inner}</AuiProvider>;
   },
 );

package/src/react/AssistantRuntimeProvider.test.tsx

@@ -0,0 +1,101 @@
+// @vitest-environment jsdom
+
+import type { ReactNode } from "react";
+import { useEffect } from "react";
+import { cleanup, render } from "@testing-library/react";
+import { afterEach, describe, expect, it } from "vitest";
+import { resource } from "@assistant-ui/tap";
+import { AuiProvider, useAui, type AssistantClient } from "@assistant-ui/store";
+import type { ChatModelAdapter } from "../runtime/utils/chat-model-adapter";
+import { AssistantRuntimeProvider } from "./AssistantRuntimeProvider";
+import { useLocalRuntime } from "./runtimes/useLocalRuntime";
+
+type AnyClient = Record<string, any>;
+
+const chatModel: ChatModelAdapter = {
+  run: async () => ({ content: [] }),
+};
+
+const makeCounterClient = (log?: string[]) => {
+  const useCounterClient = () => {
+    useEffect(() => {
+      log?.push("parent tap effect");
+    }, []);
+    return { getState: () => ({ count: 0 }) };
+  };
+  return resource(useCounterClient);
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("AssistantRuntimeProvider aui composition", () => {
+  it("isolates from ambient context by default", () => {
+    let aui!: AnyClient;
+    const Consumer = () => {
+      aui = useAui();
+      return null;
+    };
+
+    const Ambient = ({ children }: { children: ReactNode }) => {
+      const ambient = useAui({
+        parentScope: makeCounterClient()(),
+      } as unknown as useAui.Props);
+      return <AuiProvider value={ambient}>{children}</AuiProvider>;
+    };
+
+    const App = () => {
+      const runtime = useLocalRuntime(chatModel);
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <Consumer />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(
+      <Ambient>
+        <App />
+      </Ambient>,
+    );
+
+    expect(aui.threads).toBeDefined();
+    expect(() => aui.parentScope.getState()).toThrow(
+      /The current scope does not have a "parentScope" property/,
+    );
+  });
+
+  it("inherits a prop-passed parent and mounts its effects", () => {
+    const log: string[] = [];
+    let aui!: AnyClient;
+    const Consumer = () => {
+      aui = useAui();
+      useEffect(() => {
+        log.push("consumer effect");
+      }, []);
+      return null;
+    };
+
+    const App = ({ parent }: { parent: AssistantClient }) => {
+      const runtime = useLocalRuntime(chatModel);
+      return (
+        <AssistantRuntimeProvider runtime={runtime} aui={parent}>
+          <Consumer />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    const Root = () => {
+      const parent = useAui({
+        parentScope: makeCounterClient(log)(),
+      } as unknown as useAui.Props);
+      return <App parent={parent} />;
+    };
+
+    render(<Root />);
+
+    expect(aui.parentScope.getState()).toEqual({ count: 0 });
+    expect(log).toEqual(["parent tap effect", "consumer effect"]);
+  });
+});

package/src/react/adapters/LocalStorageThreadListAdapter.tsx

@@ -1,5 +1,12 @@
 import { type AssistantStream, createAssistantStream } from "assistant-stream";
-import { type FC, type PropsWithChildren, useMemo } from "react";
+import {
+  type FC,
+  type PropsWithChildren,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { useAui } from "@assistant-ui/store";
 import type {
   RemoteThreadInitializeResponse,
@@ -276,22 +283,26 @@ export const parseStoredMessageRepository = (
 
 class AsyncStorageHistoryAdapter implements ThreadHistoryAdapter {
   private storage: AsyncStorageLike;
-  private aui: ReturnType<typeof useAui>;
+  private getAui: () => ReturnType<typeof useAui>;
   private prefix: string;
   private mutationQueue: KeyedMutationQueue;
 
   constructor(
     storage: AsyncStorageLike,
-    aui: ReturnType<typeof useAui>,
+    getAui: () => ReturnType<typeof useAui>,
     prefix: string,
     mutationQueue: KeyedMutationQueue,
   ) {
     this.storage = storage;
-    this.aui = aui;
+    this.getAui = getAui;
     this.prefix = prefix;
     this.mutationQueue = mutationQueue;
   }
 
+  private get aui(): ReturnType<typeof useAui> {
+    return this.getAui();
+  }
+
   private _messagesKey(remoteId: string) {
     return `${this.prefix}messages:${remoteId}`;
   }
@@ -334,9 +345,19 @@ const createHistoryProvider = (
 ): FC<PropsWithChildren> => {
   const Provider: FC<PropsWithChildren> = ({ children }) => {
     const aui = useAui();
-    const history = useMemo(
-      () => new AsyncStorageHistoryAdapter(storage, aui, prefix, mutationQueue),
-      [aui],
+    // Not useEffectEvent: history adapter methods run during render (SSR load).
+    const auiRef = useRef(aui);
+    useEffect(() => {
+      auiRef.current = aui;
+    });
+    const [history] = useState(
+      () =>
+        new AsyncStorageHistoryAdapter(
+          storage,
+          () => auiRef.current,
+          prefix,
+          mutationQueue,
+        ),
     );
     const adapters = useMemo(() => ({ history }), [history]);
 

package/src/react/index.ts

@@ -226,6 +226,10 @@ export {
   type StreamingTimingOptions,
   type StreamingTimingState,
 } from "./runtimes/useStreamingTiming";
+export {
+  createRuntimeExtras,
+  type RuntimeExtras,
+} from "./runtimes/createRuntimeExtras";
 export { RemoteThreadListHookInstanceManager } from "./runtimes/RemoteThreadListHookInstanceManager";
 export { RemoteThreadListThreadListRuntimeCore } from "./runtimes/RemoteThreadListThreadListRuntimeCore";
 export { useRemoteThreadListRuntime } from "./runtimes/useRemoteThreadListRuntime";

package/src/react/primitive-hooks/useActionBarCopy.test.ts

@@ -1,3 +1,5 @@
+/** @vitest-environment jsdom */
+import { cleanup, renderHook } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 const mocks = vi.hoisted(() => {
@@ -23,18 +25,18 @@ const mocks = vi.hoisted(() => {
         setIsCopied,
       },
     },
+    currentAui: {
+      message: {
+        getCopyText: () => "Hello",
+        setIsCopied,
+      },
+    },
   };
 });
 
-vi.mock("react", async (importOriginal) => ({
-  ...(await importOriginal<typeof import("react")>()),
-  useCallback: ((callback: unknown) =>
-    callback) as typeof import("react").useCallback,
-}));
-
 vi.mock("@assistant-ui/store", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/store")>()),
-  useAui: () => mocks.aui,
+  useAui: () => mocks.currentAui,
   useAuiState: ((selector: (state: typeof mocks.state) => unknown) =>
     selector(mocks.state)) as typeof import("@assistant-ui/store").useAuiState,
 }));
@@ -42,25 +44,28 @@ vi.mock("@assistant-ui/store", async (importOriginal) => ({
 import { useActionBarCopy } from "./useActionBarCopy";
 
 afterEach(() => {
+  cleanup();
   vi.clearAllMocks();
+  vi.useRealTimers();
+  mocks.currentAui = mocks.aui;
 });
 
 describe("useActionBarCopy", () => {
   it("does not report copy success without a clipboard handler", async () => {
-    const { copy, disabled } = useActionBarCopy();
+    const { result } = renderHook(() => useActionBarCopy());
 
-    copy();
+    result.current.copy();
     await Promise.resolve();
 
-    expect(disabled).toBe(true);
+    expect(result.current.disabled).toBe(true);
     expect(mocks.setIsCopied).not.toHaveBeenCalled();
   });
 
   it("reports copy success after the clipboard handler resolves", async () => {
     const copyToClipboard = vi.fn();
-    const { copy } = useActionBarCopy({ copyToClipboard });
+    const { result } = renderHook(() => useActionBarCopy({ copyToClipboard }));
 
-    copy();
+    result.current.copy();
     await Promise.resolve();
 
     expect(copyToClipboard).toHaveBeenCalledWith("Hello");
@@ -69,11 +74,101 @@ describe("useActionBarCopy", () => {
 
   it("does not report copy success when the clipboard handler rejects", async () => {
     const copyToClipboard = vi.fn().mockRejectedValue(new Error("denied"));
-    const { copy } = useActionBarCopy({ copyToClipboard });
+    const { result } = renderHook(() => useActionBarCopy({ copyToClipboard }));
+
+    result.current.copy();
+    await Promise.resolve();
+
+    expect(mocks.setIsCopied).not.toHaveBeenCalled();
+  });
+
+  it("keeps copy success visible for the full duration after copying again", async () => {
+    vi.useFakeTimers();
+    const copyToClipboard = vi.fn();
+    const { result } = renderHook(() =>
+      useActionBarCopy({
+        copiedDuration: 3000,
+        copyToClipboard,
+      }),
+    );
+
+    result.current.copy();
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(1000);
+
+    result.current.copy();
+    await Promise.resolve();
+    mocks.setIsCopied.mockClear();
+
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(mocks.setIsCopied).not.toHaveBeenCalledWith(false);
 
-    copy();
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mocks.setIsCopied).toHaveBeenCalledWith(false);
+  });
+
+  it("resets copy feedback when unmounted", async () => {
+    vi.useFakeTimers();
+    const copyToClipboard = vi.fn();
+    const { result, unmount } = renderHook(() =>
+      useActionBarCopy({ copyToClipboard }),
+    );
+
+    result.current.copy();
+    await Promise.resolve();
+    expect(vi.getTimerCount()).toBe(1);
+
+    mocks.setIsCopied.mockClear();
+    unmount();
+
+    expect(vi.getTimerCount()).toBe(0);
+    expect(mocks.setIsCopied).toHaveBeenCalledWith(false);
+  });
+
+  it("ignores clipboard success after unmount", async () => {
+    vi.useFakeTimers();
+    let resolveCopy: (() => void) | undefined;
+    const copyToClipboard = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveCopy = resolve;
+        }),
+    );
+    const { result, unmount } = renderHook(() =>
+      useActionBarCopy({ copyToClipboard }),
+    );
+
+    result.current.copy();
+    unmount();
+    resolveCopy?.();
     await Promise.resolve();
 
     expect(mocks.setIsCopied).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("resets feedback for the previous message scope", async () => {
+    vi.useFakeTimers();
+    const copyToClipboard = vi.fn();
+    const nextSetIsCopied = vi.fn();
+    const { result, rerender } = renderHook(() =>
+      useActionBarCopy({ copyToClipboard }),
+    );
+
+    result.current.copy();
+    await Promise.resolve();
+    mocks.setIsCopied.mockClear();
+
+    mocks.currentAui = {
+      message: {
+        getCopyText: () => "Next message",
+        setIsCopied: nextSetIsCopied,
+      },
+    };
+    rerender();
+
+    expect(mocks.setIsCopied).toHaveBeenCalledWith(false);
+    expect(nextSetIsCopied).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
   });
 });

package/src/react/primitive-hooks/useActionBarCopy.ts

@@ -1,4 +1,4 @@
-import { useCallback } from "react";
+import { useCallback, useEffect, useRef } from "react";
 import { useAui, useAuiState } from "@assistant-ui/store";
 
 export type UseActionBarCopyOptions = {
@@ -21,19 +21,44 @@ export const useActionBarCopy = ({
   const isCopied = useAuiState((s) => s.message.isCopied);
   const isEditing = useAuiState((s) => s.composer.isEditing);
   const composerValue = useAuiState((s) => s.composer.text);
+  const copiedTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(
+    undefined,
+  );
+  const scopeGenerationRef = useRef(0);
+
+  useEffect(
+    () => () => {
+      scopeGenerationRef.current += 1;
+      if (copiedTimerRef.current === undefined) return;
+
+      clearTimeout(copiedTimerRef.current);
+      copiedTimerRef.current = undefined;
+      aui.message.setIsCopied(false);
+    },
+    [aui],
+  );
 
   const copy = useCallback(() => {
     if (!copyToClipboard) return;
 
     const valueToCopy = isEditing ? composerValue : aui.message.getCopyText();
     if (!valueToCopy) return;
+    const scopeGeneration = scopeGenerationRef.current;
 
     // The rejection handler swallows clipboard write failures (permission denied,
     // API unavailable) so they don't surface as unhandled promise rejections.
     Promise.resolve(copyToClipboard(valueToCopy)).then(
       () => {
+        if (scopeGeneration !== scopeGenerationRef.current) return;
+
+        if (copiedTimerRef.current !== undefined) {
+          clearTimeout(copiedTimerRef.current);
+        }
         aui.message.setIsCopied(true);
-        setTimeout(() => aui.message.setIsCopied(false), copiedDuration);
+        copiedTimerRef.current = setTimeout(() => {
+          copiedTimerRef.current = undefined;
+          aui.message.setIsCopied(false);
+        }, copiedDuration);
       },
       () => {},
     );

package/src/react/primitives/message/MessageGroupedParts.tsx

@@ -8,6 +8,7 @@ import type {
   MessagePartStatus,
   ToolCallMessagePartStatus,
 } from "../../../types/message";
+import { getGroupStatus } from "../../../utils/getGroupStatus";
 import {
   buildGroupTree,
   GROUPBY_MEMO_KEY,
@@ -21,7 +22,8 @@ export namespace MessagePrimitiveGroupedParts {
    * A coalesced group of adjacent parts. Surfaced through the same
    * `{ part }` channel as a leaf {@link EnrichedPartState} so consumers
    * dispatch on a single `switch (part.type)`. `type` is the group key
-   * (always `"group-…"`); `status` mirrors the last contained part.
+   * (always `"group-…"`); `status` is running when any contained part runs,
+   * otherwise it mirrors the last contained part.
    */
   export type GroupPart<TKey extends `group-${string}` = `group-${string}`> = {
     readonly type: TKey;
@@ -133,8 +135,6 @@ export namespace MessagePrimitiveGroupedParts {
   };
 }
 
-const COMPLETE_STATUS: MessagePartStatus = Object.freeze({ type: "complete" });
-
 const shouldShowIndicator = (
   mode: MessagePrimitiveGroupedParts.IndicatorMode,
   parts: readonly PartState[],
@@ -194,7 +194,7 @@ const renderNode = <TKey extends `group-${string}`>(
     );
   }
 
-  const status = parts[node.indices.at(-1)!]?.status ?? COMPLETE_STATUS;
+  const status = getGroupStatus(parts, node.indices);
   const groupPart: MessagePrimitiveGroupedParts.GroupPart<TKey> = {
     type: node.key as TKey,
     status,