@assistant-ui/core 0.3.19 → 0.3.21

package/src/react/interactables-legacy/Interactables.ts

@@ -9,13 +9,15 @@ import { useAssistantScopeEffect } from "@assistant-ui/store/client";
 import type {
   InteractablesState,
   InteractableRegistration,
-  InteractableStateSchema,
   InteractablePersistedState,
   InteractablePersistenceAdapter,
 } from "./scopes";
-import { toJSONSchema, toPartialJSONSchema } from "assistant-stream";
+import { toJSONSchema } from "assistant-stream";
 import { ModelContext } from "../../store";
-import { buildInteractableModelContext } from "./interactable-model-context";
+import {
+  buildInteractableModelContext,
+  type StateJSONSchema,
+} from "./interactable-model-context";
 import { notifySubscribers as notifyStateSubscribers } from "../../subscribable/subscribable";
 import { useInteractablePersistenceQueue } from "../interactables-shared/useInteractablePersistenceQueue";
 import { nullProtoRecord } from "../../utils/record";
@@ -40,14 +42,16 @@ const useInteractables = (): ClientOutput<"interactables"> => {
   );
 
   const subscribersRef = useRef(new Set<() => void>());
-  const partialSchemaCacheRef = useRef(
-    new Map<string, InteractableStateSchema>(),
-  );
+  const schemaCacheRef = useRef(new Map<string, StateJSONSchema>());
   const detachedStateRef = useRef(new Map<string, unknown>());
 
   const adapterRef = useRef<InteractablePersistenceAdapter | undefined>(
     undefined,
   );
+  const adapterGenerationRef = useRef(0);
+  const lastAttachedAdapterRef = useRef<
+    InteractablePersistenceAdapter | undefined
+  >(undefined);
 
   const exportState = useCallback((): InteractablePersistedState => {
     const result = nullProtoRecord<InteractablePersistedState[string]>();
@@ -76,6 +80,7 @@ const useInteractables = (): ClientOutput<"interactables"> => {
   const { flushIfPending, schedulePersistence, flush } =
     useInteractablePersistenceQueue({
       adapterRef,
+      adapterGenerationRef,
       snapshot: exportState,
       updatePersistenceStatus,
     });
@@ -104,6 +109,15 @@ const useInteractables = (): ClientOutput<"interactables"> => {
     (adapter: InteractablePersistenceAdapter | undefined) => {
       if (adapterRef.current !== adapter) flushIfPending();
       adapterRef.current = adapter;
+      if (!adapter) return;
+
+      // Only a genuine replacement opens a new scope, so a detach and reattach
+      // of the same adapter keeps an in-flight save's failure in its own scope.
+      const lastAttached = lastAttachedAdapterRef.current;
+      lastAttachedAdapterRef.current = adapter;
+      if (lastAttached !== undefined && lastAttached !== adapter) {
+        adapterGenerationRef.current += 1;
+      }
     },
     [flushIfPending],
   );
@@ -148,7 +162,7 @@ const useInteractables = (): ClientOutput<"interactables"> => {
         return (
           buildInteractableModelContext(
             defs,
-            partialSchemaCacheRef.current,
+            schemaCacheRef.current,
             setDefState,
           ) ?? {}
         );
@@ -175,15 +189,12 @@ const useInteractables = (): ClientOutput<"interactables"> => {
 
   const register = useCallback(
     (def: InteractableRegistration) => {
+      schemaCacheRef.current.delete(def.id);
       try {
-        const jsonSchema = toJSONSchema(def.stateSchema);
-        partialSchemaCacheRef.current.set(
-          def.id,
-          toPartialJSONSchema(jsonSchema),
-        );
+        schemaCacheRef.current.set(def.id, toJSONSchema(def.stateSchema));
       } catch (e) {
         console.warn(
-          `[Interactables] Failed to create partial schema for "${def.name}". The update tool will require all fields.`,
+          `[Interactables] Failed to convert the state schema of "${def.name}" to JSON Schema. The update tool will require all fields.`,
           e,
         );
       }
@@ -213,7 +224,7 @@ const useInteractables = (): ClientOutput<"interactables"> => {
           if (existing) {
             detachedStateRef.current.set(def.id, existing.state);
           }
-          partialSchemaCacheRef.current.delete(def.id);
+          schemaCacheRef.current.delete(def.id);
           const definitions = nullProtoRecord(prev.definitions);
           const persistence = nullProtoRecord(prev.persistence);
           delete definitions[def.id];

package/src/react/interactables-legacy/interactable-model-context.ts

@@ -1,26 +1,21 @@
-import type { Tool } from "assistant-stream";
-import type { InteractableDefinition, InteractableStateSchema } from "./scopes";
+import type { Tool, toJSONSchema } from "assistant-stream";
+import { getPartialJsonObjectMeta } from "assistant-stream/utils";
+import { overlayPartialPath } from "../../model-context/interactable-composer-metadata";
+import type { InteractableDefinition } from "./scopes";
 
-export function shallowMerge(prev: unknown, partial: unknown): unknown {
-  if (
-    typeof prev !== "object" ||
-    prev === null ||
-    typeof partial !== "object" ||
-    partial === null ||
-    Array.isArray(prev) ||
-    Array.isArray(partial)
-  ) {
-    return partial;
-  }
-  return {
-    ...(prev as Record<string, unknown>),
-    ...(partial as Record<string, unknown>),
-  };
-}
+export type StateJSONSchema = ReturnType<typeof toJSONSchema>;
+
+// The spread also drops the non-enumerable `~standard` zod attaches to its
+// JSON Schema output; carried over, the tool runtime would validate every
+// partial update against the full state schema.
+const withoutRootRequired = ({
+  required: _required,
+  ...schema
+}: StateJSONSchema) => schema;
 
 export function buildInteractableModelContext(
   definitions: Record<string, InteractableDefinition>,
-  partialSchemaCache: Map<string, InteractableStateSchema>,
+  schemaCache: Map<string, StateJSONSchema>,
   setDefState: (id: string, updater: (prev: unknown) => unknown) => void,
 ): { system: string; tools: Record<string, Tool<any, any>> } | undefined {
   const entries = Object.values(definitions);
@@ -53,23 +48,30 @@ export function buildInteractableModelContext(
         ? `update_${safeName}_${safeId}`
         : `update_${safeName}`;
 
-      const partialSchema = partialSchemaCache.get(def.id) ?? def.stateSchema;
+      const jsonSchema = schemaCache.get(def.id);
 
       tools[toolName] = {
         type: "frontend" as const,
-        description: `Update the state of interactable component "${name}"${isMulti ? ` (id: ${def.id})` : ""}. Only include the fields you want to change; omitted fields keep their current values. ${def.description}`,
-        parameters: partialSchema,
+        description: `Update the state of interactable component "${name}"${isMulti ? ` (id: ${def.id})` : ""}. Only include the fields you want to change; omitted fields keep their current values. A nested object replaces the existing one, so send it complete. ${def.description}`,
+        parameters: jsonSchema
+          ? withoutRootRequired(jsonSchema)
+          : def.stateSchema,
         streamCall: async (reader) => {
           try {
             for await (const partialArgs of reader.args.streamValues()) {
-              setDefState(def.id, (prev) => shallowMerge(prev, partialArgs));
+              const partialPath = getPartialJsonObjectMeta(
+                partialArgs as Record<symbol, unknown>,
+              )?.partialPath;
+              setDefState(def.id, (prev) =>
+                overlayPartialPath(prev, partialArgs, partialPath),
+              );
             }
           } catch {
             // Non-fatal: execute handles the final state
           }
         },
         execute: async (partialState: unknown) => {
-          setDefState(def.id, (prev) => shallowMerge(prev, partialState));
+          setDefState(def.id, (prev) => overlayPartialPath(prev, partialState));
           return { success: true };
         },
       };

package/src/react/interactables-legacy/useAssistantInteractable.test.tsx

@@ -2,6 +2,17 @@
 
 import { cleanup, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import type { InteractableStateSchema } from "./scopes";
+
+type JsonSchema = Exclude<InteractableStateSchema, { "~standard": unknown }>;
+type StandardSchemaWithJsonSchema = Extract<
+  InteractableStateSchema,
+  { "~standard": unknown }
+> & {
+  "~standard": {
+    jsonSchema: { input: () => JsonSchema; output: () => JsonSchema };
+  };
+};
 
 const mocks = vi.hoisted(() => {
   const unregister = vi.fn();
@@ -28,17 +39,20 @@ afterEach(() => {
 describe("useAssistantInteractable", () => {
   it("refreshes the registration when its JSON schema changes", async () => {
     const schemaA = {
-      type: "object" as const,
+      type: "object",
       properties: { first: { type: "string" } },
-    };
+    } satisfies InteractableStateSchema;
     const schemaB = {
-      type: "object" as const,
+      type: "object",
       properties: { second: { type: "number" } },
-    };
+    } satisfies InteractableStateSchema;
     const initialA = { first: "one" };
     const initialB = { second: 2 };
 
-    const hook = renderHook(
+    const hook = renderHook<
+      unknown,
+      { stateSchema: InteractableStateSchema; initialState: unknown }
+    >(
       ({ stateSchema, initialState }) =>
         useAssistantInteractable("panel", {
           id: "panel-1",
@@ -69,20 +83,23 @@ describe("useAssistantInteractable", () => {
   });
 
   it("stabilizes equivalent rebuilt standard schemas", async () => {
-    const createSchema = (property: string) => ({
+    const createSchema = (property: string): StandardSchemaWithJsonSchema => ({
       "~standard": {
-        version: 1 as const,
+        version: 1,
         vendor: "test",
-        validate: (value: unknown) => ({ value }),
-        toJSONSchema: () => ({
-          type: "object" as const,
-          properties: { [property]: { type: "string" as const } },
-        }),
+        validate: () => ({ value: {} }),
+        jsonSchema: {
+          input: () => ({
+            type: "object",
+            properties: { [property]: { type: "string" } },
+          }),
+          output: () => ({ type: "object" }),
+        },
       },
     });
     const firstSchema = createSchema("value");
 
-    const hook = renderHook(
+    const hook = renderHook<unknown, { stateSchema: InteractableStateSchema }>(
       ({ stateSchema }) =>
         useAssistantInteractable("panel", {
           id: "panel-1",
@@ -106,15 +123,16 @@ describe("useAssistantInteractable", () => {
   });
 
   it("keeps unsupported standard schemas from failing during render", async () => {
-    const createSchema = () => ({
-      "~standard": {
-        version: 1 as const,
-        vendor: "test",
-        validate: (value: unknown) => ({ value }),
-      },
-    });
-
-    const hook = renderHook(
+    const createSchema = () =>
+      ({
+        "~standard": {
+          version: 1 as const,
+          vendor: "test",
+          validate: () => ({ value: {} }),
+        },
+      }) satisfies InteractableStateSchema;
+
+    const hook = renderHook<unknown, { stateSchema: InteractableStateSchema }>(
       ({ stateSchema }) =>
         useAssistantInteractable("panel", {
           id: "panel-1",

package/src/react/interactables-shared/useInteractablePersistenceQueue.test.tsx

@@ -23,10 +23,15 @@ const createDeferred = () => {
   return { promise, resolve, reject };
 };
 
-const renderQueue = (save: (state: TestState) => void | Promise<void>) => {
+const renderQueue = (
+  save: ((state: TestState) => void | Promise<void>) | undefined,
+) => {
   let snapshot: TestState = {};
   let persistence: PersistenceStatusMap = {};
-  const adapterRef = { current: { save } };
+  const adapterRef: {
+    current: { save: (state: TestState) => void | Promise<void> } | undefined;
+  } = { current: save ? { save } : undefined };
+  const adapterGenerationRef = { current: 0 };
   const updatePersistenceStatus = (
     updater: (prev: PersistenceStatusMap) => PersistenceStatusMap,
   ) => {
@@ -35,6 +40,7 @@ const renderQueue = (save: (state: TestState) => void | Promise<void>) => {
   const hook = renderHook(() =>
     useInteractablePersistenceQueue({
       adapterRef,
+      adapterGenerationRef,
       snapshot: () => snapshot,
       updatePersistenceStatus,
     }),
@@ -68,6 +74,20 @@ afterEach(() => {
 });
 
 describe("useInteractablePersistenceQueue", () => {
+  it("resolves flush while edits wait for an adapter", async () => {
+    const queue = renderQueue(undefined);
+
+    queue.setState("a", 1);
+    act(() => queue.result.current.schedulePersistence("a"));
+
+    let flushPromise!: Promise<void>;
+    act(() => {
+      flushPromise = queue.result.current.flush();
+    });
+
+    await expect(flushPromise).resolves.toBeUndefined();
+  });
+
   it("coalesces dirty marks inside the debounce window into one save", async () => {
     const save = vi.fn<(state: TestState) => void>();
     const queue = renderQueue(save);

package/src/react/interactables-shared/useInteractablePersistenceQueue.ts

@@ -1,7 +1,14 @@
 import { useCallback, useRef, type RefObject } from "react";
 import { nullProtoRecord } from "../../utils/record";
 
-const PERSISTENCE_DEBOUNCE_MS = 500;
+export const PERSISTENCE_DEBOUNCE_MS = 500;
+
+/**
+ * `load` is caller code with no settling contract, so an awaited `flush` bounds
+ * the wait rather than inheriting it. Past this the edit stays queued for the
+ * next successful snapshot, which is the same shape a failed load already has.
+ */
+export const FLUSH_LOAD_TIMEOUT_MS = 5_000;
 
 type PersistenceAdapter<State> = {
   save(state: State): void | Promise<void>;
@@ -20,14 +27,18 @@ type PersistenceStatusUpdater = (
 
 type UseInteractablePersistenceQueueOptions<State> = {
   adapterRef: RefObject<PersistenceAdapter<State> | undefined>;
+  adapterGenerationRef: RefObject<number>;
   snapshot: () => State;
   updatePersistenceStatus: PersistenceStatusUpdater;
+  retainDirtyWithoutAdapter?: boolean;
 };
 
 export const useInteractablePersistenceQueue = <State>({
   adapterRef,
+  adapterGenerationRef,
   snapshot,
   updatePersistenceStatus,
+  retainDirtyWithoutAdapter = false,
 }: UseInteractablePersistenceQueueOptions<State>) => {
   const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(
     undefined,
@@ -43,6 +54,7 @@ export const useInteractablePersistenceQueue = <State>({
     payload: State;
     dirtyIds: Set<string>;
     seq: number;
+    adapterGeneration: number;
   };
 
   const outgoingQueueRef = useRef<PersistenceBatch[]>([]);
@@ -57,9 +69,15 @@ export const useInteractablePersistenceQueue = <State>({
       dirtyIdsRef.current.clear();
       const seq = ++syncSeqRef.current;
       for (const id of dirtyIds) latestSyncSeqByIdRef.current.set(id, seq);
-      return { adapter, payload: snapshot(), dirtyIds, seq };
+      return {
+        adapter,
+        adapterGeneration: adapterGenerationRef.current,
+        payload: snapshot(),
+        dirtyIds,
+        seq,
+      };
     },
-    [snapshot],
+    [adapterGenerationRef, snapshot],
   );
 
   const enqueuePersistence = useCallback(
@@ -88,7 +106,7 @@ export const useInteractablePersistenceQueue = <State>({
         return;
       }
 
-      const { adapter, payload, dirtyIds, seq } = resolved;
+      const { adapter, adapterGeneration, payload, dirtyIds, seq } = resolved;
       inFlightPersistenceRef.current += 1;
 
       updatePersistenceStatus((prev) => {
@@ -128,7 +146,17 @@ export const useInteractablePersistenceQueue = <State>({
         await adapter.save(payload);
         settleBatch(undefined);
       } catch (e) {
-        settleBatch({ isPending: false, error: e });
+        const isCurrentScope =
+          adapterGenerationRef.current === adapterGeneration;
+        if (!isCurrentScope) {
+          console.warn(
+            "[Interactables] Persistence save failed after the adapter changed.",
+            e,
+          );
+        }
+        settleBatch(
+          isCurrentScope ? { isPending: false, error: e } : undefined,
+        );
       } finally {
         inFlightPersistenceRef.current -= 1;
         const next =
@@ -148,7 +176,7 @@ export const useInteractablePersistenceQueue = <State>({
         }
       }
     },
-    [adapterRef, takeDirtyBatch, updatePersistenceStatus],
+    [adapterGenerationRef, adapterRef, takeDirtyBatch, updatePersistenceStatus],
   );
   runPersistenceRef.current = (nextBatch) => {
     void runPersistence(nextBatch);
@@ -164,8 +192,9 @@ export const useInteractablePersistenceQueue = <State>({
 
   const schedulePersistence = useCallback(
     (id: string) => {
-      if (!adapterRef.current) return;
+      if (!adapterRef.current && !retainDirtyWithoutAdapter) return;
       dirtyIdsRef.current.add(id);
+      if (!adapterRef.current) return;
       if (debounceTimerRef.current !== undefined) {
         clearTimeout(debounceTimerRef.current);
       }
@@ -181,9 +210,26 @@ export const useInteractablePersistenceQueue = <State>({
         }
       }, PERSISTENCE_DEBOUNCE_MS);
     },
-    [adapterRef, enqueuePersistence],
+    [adapterRef, enqueuePersistence, retainDirtyWithoutAdapter],
   );
 
+  const discardPending = useCallback(() => {
+    if (debounceTimerRef.current !== undefined) {
+      clearTimeout(debounceTimerRef.current);
+      debounceTimerRef.current = undefined;
+    }
+    dirtyIdsRef.current.clear();
+    if (
+      inFlightPersistenceRef.current === 0 &&
+      outgoingQueueRef.current.length === 0
+    ) {
+      for (const resolve of flushResolversRef.current) resolve();
+      flushResolversRef.current = [];
+    }
+  }, []);
+
+  const getDirtyIds = useCallback(() => new Set(dirtyIdsRef.current), []);
+
   const flush = useCallback(async () => {
     if (debounceTimerRef.current !== undefined) {
       clearTimeout(debounceTimerRef.current);
@@ -191,8 +237,8 @@ export const useInteractablePersistenceQueue = <State>({
     }
     const hasWork =
       inFlightPersistenceRef.current > 0 ||
-      dirtyIdsRef.current.size > 0 ||
-      outgoingQueueRef.current.length > 0;
+      outgoingQueueRef.current.length > 0 ||
+      (adapterRef.current !== undefined && dirtyIdsRef.current.size > 0);
     if (!hasWork) return;
     const p = new Promise<void>((resolve) => {
       flushResolversRef.current.push(resolve);
@@ -201,5 +247,11 @@ export const useInteractablePersistenceQueue = <State>({
     return p;
   }, [adapterRef, enqueuePersistence]);
 
-  return { flushIfPending, schedulePersistence, flush };
+  return {
+    discardPending,
+    flushIfPending,
+    getDirtyIds,
+    schedulePersistence,
+    flush,
+  };
 };

package/src/react/model-context/useInteractable.test.tsx

@@ -2,6 +2,20 @@
 
 import { cleanup, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import type { Unstable_InteractableStateSchema } from "../types/scopes/interactables";
+
+type JsonSchema = Exclude<
+  Unstable_InteractableStateSchema,
+  { "~standard": unknown }
+>;
+type StandardSchemaWithJsonSchema = Extract<
+  Unstable_InteractableStateSchema,
+  { "~standard": unknown }
+> & {
+  "~standard": {
+    jsonSchema: { input: () => JsonSchema; output: () => JsonSchema };
+  };
+};
 
 const mocks = vi.hoisted(() => {
   const unregister = vi.fn();
@@ -42,17 +56,20 @@ afterEach(() => {
 describe("unstable_useInteractable", () => {
   it("refreshes the registration when its JSON schema changes", async () => {
     const schemaA = {
-      type: "object" as const,
+      type: "object",
       properties: { first: { type: "string" } },
-    };
+    } satisfies Unstable_InteractableStateSchema;
     const schemaB = {
-      type: "object" as const,
+      type: "object",
       properties: { second: { type: "number" } },
-    };
+    } satisfies Unstable_InteractableStateSchema;
     const initialA = { first: "one" };
     const initialB = { second: 2 };
 
-    const hook = renderHook(
+    const hook = renderHook<
+      unknown,
+      { stateSchema: Unstable_InteractableStateSchema; initialState: unknown }
+    >(
       ({ stateSchema, initialState }) =>
         unstable_useInteractable("panel", {
           id: "panel-1",
@@ -83,20 +100,26 @@ describe("unstable_useInteractable", () => {
   });
 
   it("stabilizes equivalent rebuilt standard schemas", async () => {
-    const createSchema = (property: string) => ({
+    const createSchema = (property: string): StandardSchemaWithJsonSchema => ({
       "~standard": {
-        version: 1 as const,
+        version: 1,
         vendor: "test",
-        validate: (value: unknown) => ({ value }),
-        toJSONSchema: () => ({
-          type: "object" as const,
-          properties: { [property]: { type: "string" as const } },
-        }),
+        validate: () => ({ value: {} }),
+        jsonSchema: {
+          input: () => ({
+            type: "object",
+            properties: { [property]: { type: "string" } },
+          }),
+          output: () => ({ type: "object" }),
+        },
       },
     });
     const firstSchema = createSchema("value");
 
-    const hook = renderHook(
+    const hook = renderHook<
+      unknown,
+      { stateSchema: Unstable_InteractableStateSchema }
+    >(
       ({ stateSchema }) =>
         unstable_useInteractable("panel", {
           id: "panel-1",
@@ -120,15 +143,19 @@ describe("unstable_useInteractable", () => {
   });
 
   it("keeps unsupported standard schemas from failing during render", async () => {
-    const createSchema = () => ({
-      "~standard": {
-        version: 1 as const,
-        vendor: "test",
-        validate: (value: unknown) => ({ value }),
-      },
-    });
-
-    const hook = renderHook(
+    const createSchema = () =>
+      ({
+        "~standard": {
+          version: 1 as const,
+          vendor: "test",
+          validate: () => ({ value: {} }),
+        },
+      }) satisfies Unstable_InteractableStateSchema;
+
+    const hook = renderHook<
+      unknown,
+      { stateSchema: Unstable_InteractableStateSchema }
+    >(
       ({ stateSchema }) =>
         unstable_useInteractable("panel", {
           id: "panel-1",
@@ -145,20 +172,20 @@ describe("unstable_useInteractable", () => {
   });
 
   it("converts a referentially stable schema only once", async () => {
-    const toJSONSchema = vi.fn(() => ({
+    const convert = vi.fn(() => ({
       type: "object" as const,
       properties: { value: { type: "string" as const } },
     }));
-    const stateSchema = {
+    const stateSchema: StandardSchemaWithJsonSchema = {
       "~standard": {
-        version: 1 as const,
+        version: 1,
         vendor: "test",
-        validate: (value: unknown) => ({ value }),
-        toJSONSchema,
+        validate: () => ({ value: {} }),
+        jsonSchema: { input: convert, output: convert },
       },
     };
 
-    const hook = renderHook(
+    const hook = renderHook<unknown, { initialState: Record<string, unknown> }>(
       ({ initialState }) =>
         unstable_useInteractable("panel", {
           id: "panel-1",
@@ -171,7 +198,7 @@ describe("unstable_useInteractable", () => {
     await waitFor(() => expect(mocks.register).toHaveBeenCalledTimes(1));
 
     hook.rerender({ initialState: { value: "second" } });
-    expect(toJSONSchema).toHaveBeenCalledTimes(1);
+    expect(convert).toHaveBeenCalledTimes(1);
     expect(mocks.register).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -21,13 +21,13 @@ const mocks = vi.hoisted(() => {
     },
     aui: {
       message: {
-        getCopyText: () => "Hello",
+        getCopyText: (): string => "Hello",
         setIsCopied,
       },
     },
     currentAui: {
       message: {
-        getCopyText: () => "Hello",
+        getCopyText: (): string => "Hello",
         setIsCopied,
       },
     },
@@ -37,8 +37,8 @@ const mocks = vi.hoisted(() => {
 vi.mock("@assistant-ui/store", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/store")>()),
   useAui: () => mocks.currentAui,
-  useAuiState: ((selector: (state: typeof mocks.state) => unknown) =>
-    selector(mocks.state)) as typeof import("@assistant-ui/store").useAuiState,
+  useAuiState: (selector: (state: typeof mocks.state) => unknown) =>
+    selector(mocks.state),
 }));
 
 import { useActionBarCopy } from "./useActionBarCopy";
@@ -175,7 +175,7 @@ describe("useActionBarCopy", () => {
 
     mocks.currentAui = {
       message: {
-        getCopyText: () => "Next message",
+        getCopyText: (): string => "Next message",
         setIsCopied: nextSetIsCopied,
       },
     };