@assistant-ui/core 0.2.12 → 0.2.14

package/src/store/clients/no-op-composer-client.ts

@@ -3,11 +3,11 @@ import { resource } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import type { ComposerState } from "../scopes/composer";
 
-export const NoOpComposerClient = resource(function NoOpComposerClient({
+const useNoOpComposerClient = ({
   type,
 }: {
   type: "edit" | "thread";
-}): ClientOutput<"composer"> {
+}): ClientOutput<"composer"> => {
   const state = useMemo<ComposerState>(() => {
     return {
       isEditing: false,
@@ -71,4 +71,6 @@ export const NoOpComposerClient = resource(function NoOpComposerClient({
       throw new Error("Not supported");
     },
   };
-});
+};
+
+export const NoOpComposerClient = resource(useNoOpComposerClient);

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

@@ -1,9 +1,4 @@
-import { useEffect } from "react";
-import { useResource, resource } from "@assistant-ui/tap";
-import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
-import { ThreadListClient } from "../runtime-clients/thread-list-runtime-client";
 import {
-  useAssistantClientRef,
   Derived,
   type ScopesConfig,
   type AssistantClient,
@@ -11,25 +6,6 @@ import {
 import { ModelContext } from "./model-context-client";
 import { Suggestions } from "./suggestions";
 
-export const RuntimeAdapterResource = resource(function RuntimeAdapterResource(
-  runtime: AssistantRuntime,
-) {
-  const clientRef = useAssistantClientRef();
-
-  useEffect(() => {
-    return runtime.registerModelContextProvider(
-      clientRef.current!.modelContext(),
-    );
-  }, [runtime, clientRef]);
-
-  return useResource(
-    ThreadListClient({
-      runtime: runtime.threads,
-      __internal_assistantRuntime: runtime,
-    }),
-  );
-});
-
 export const baseRuntimeAdapterTransformScopes = (
   scopes: ScopesConfig,
   parent: AssistantClient,

package/src/store/clients/suggestions.ts

@@ -9,17 +9,19 @@ export type SuggestionConfig =
   | string
   | { title: string; label: string; prompt: string };
 
-const SuggestionClient = resource(function SuggestionClient(
+const useSuggestionClient = (
   state: SuggestionState,
-): ClientOutput<"suggestion"> {
+): ClientOutput<"suggestion"> => {
   return {
     getState: () => state,
   };
-});
+};
 
-const SuggestionsResource = resource(function SuggestionsResource(
+const SuggestionClient = resource(useSuggestionClient);
+
+const useSuggestionsResource = (
   suggestions?: SuggestionConfig[],
-): ClientOutput<"suggestions"> {
+): ClientOutput<"suggestions"> => {
   const [state] = useState<SuggestionsState>(() => {
     const normalizedSuggestions = (suggestions ?? []).map((s) => {
       if (typeof s === "string") {
@@ -55,17 +57,6 @@ const SuggestionsResource = resource(function SuggestionsResource(
       return suggestionClients.get({ index });
     },
   };
-});
+};
 
-export const Suggestions: {
-  (): import("@assistant-ui/tap").ResourceElement<
-    ClientOutput<"suggestions">,
-    undefined
-  >;
-  (
-    suggestions: SuggestionConfig[],
-  ): import("@assistant-ui/tap").ResourceElement<
-    ClientOutput<"suggestions">,
-    SuggestionConfig[]
-  >;
-} = SuggestionsResource as any;
+export const Suggestions = resource(useSuggestionsResource);

package/src/store/clients/thread-message-client.ts

@@ -11,12 +11,13 @@ import { useClientLookup } from "@assistant-ui/store";
 import type { MessageState } from "../scopes/message";
 import type { PartState } from "../scopes/part";
 import { NoOpComposerClient } from "./no-op-composer-client";
+import { getThreadMessageText } from "../../utils/text";
 
-const ThreadMessagePartClient = resource(function ThreadMessagePartClient({
+const useThreadMessagePartClient = ({
   part,
 }: {
   part: ThreadAssistantMessagePart | ThreadUserMessagePart;
-}): ClientOutput<"part"> {
+}): ClientOutput<"part"> => {
   const state = useMemo<PartState>(() => {
     return {
       ...part,
@@ -36,21 +37,25 @@ const ThreadMessagePartClient = resource(function ThreadMessagePartClient({
       throw new Error("Not supported");
     },
   };
-});
+};
+
+const ThreadMessagePartClient = resource(useThreadMessagePartClient);
+
+const useThreadMessageAttachmentClient = ({
+  attachment,
+}: {
+  attachment: Attachment;
+}): ClientOutput<"attachment"> => {
+  return {
+    getState: () => attachment,
+    remove: () => {
+      throw new Error("Not supported");
+    },
+  };
+};
 
 const ThreadMessageAttachmentClient = resource(
-  function ThreadMessageAttachmentClient({
-    attachment,
-  }: {
-    attachment: Attachment;
-  }): ClientOutput<"attachment"> {
-    return {
-      getState: () => attachment,
-      remove: () => {
-        throw new Error("Not supported");
-      },
-    };
-  },
+  useThreadMessageAttachmentClient,
 );
 export type ThreadMessageClientProps = {
   message: ThreadMessage;
@@ -60,13 +65,13 @@ export type ThreadMessageClientProps = {
   branchCount?: number;
 };
 
-export const ThreadMessageClient = resource(function ThreadMessageClient({
+const useThreadMessageClient = ({
   message,
   index,
   isLast = true,
   branchNumber = 1,
   branchCount = 1,
-}: ThreadMessageClientProps): ClientOutput<"message"> {
+}: ThreadMessageClientProps): ClientOutput<"message"> => {
   const [isCopiedState, setIsCopied] = useState(false);
   const [isHoveringState, setIsHovering] = useState(false);
 
@@ -137,6 +142,9 @@ export const ThreadMessageClient = resource(function ThreadMessageClient({
         return attachments.get(selector);
       }
     },
+    delete: () => {
+      throw new Error("Not supported in ThreadMessageProvider");
+    },
     reload: () => {
       throw new Error("Not supported in ThreadMessageProvider");
     },
@@ -153,16 +161,11 @@ export const ThreadMessageClient = resource(function ThreadMessageClient({
       throw new Error("Not supported in ThreadMessageProvider");
     },
     getCopyText: () => {
-      return message.content
-        .map((part) => {
-          if ("text" in part && typeof part.text === "string") {
-            return part.text;
-          }
-          return "";
-        })
-        .join("\n");
+      return getThreadMessageText(message);
     },
     setIsCopied,
     setIsHovering,
   };
-});
+};
+
+export const ThreadMessageClient = resource(useThreadMessageClient);

package/src/store/internal.ts

@@ -5,7 +5,4 @@ export { MessageClient } from "./runtime-clients/message-runtime-client";
 export { ThreadClient } from "./runtime-clients/thread-runtime-client";
 export { ThreadListItemClient } from "./runtime-clients/thread-list-item-runtime-client";
 export { ThreadListClient } from "./runtime-clients/thread-list-runtime-client";
-export {
-  RuntimeAdapterResource,
-  baseRuntimeAdapterTransformScopes,
-} from "./clients/runtime-adapter";
+export { baseRuntimeAdapterTransformScopes } from "./clients/runtime-adapter";

package/src/store/runtime-clients/attachment-runtime-client.ts

@@ -3,18 +3,18 @@ import type { ClientOutput } from "@assistant-ui/store";
 import type { AttachmentRuntime } from "../../runtime/api/attachment-runtime";
 import { useSubscribable } from "./useSubscribable";
 
-export const AttachmentRuntimeClient = resource(
-  function AttachmentRuntimeClient({
-    runtime,
-  }: {
-    runtime: AttachmentRuntime;
-  }): ClientOutput<"attachment"> {
-    const state = useSubscribable(runtime);
+const useAttachmentRuntimeClient = ({
+  runtime,
+}: {
+  runtime: AttachmentRuntime;
+}): ClientOutput<"attachment"> => {
+  const state = useSubscribable(runtime);
 
-    return {
-      getState: () => state,
-      remove: runtime.remove,
-      __internal_getRuntime: () => runtime,
-    };
-  },
-);
+  return {
+    getState: () => state,
+    remove: runtime.remove,
+    __internal_getRuntime: () => runtime,
+  };
+};
+
+export const AttachmentRuntimeClient = resource(useAttachmentRuntimeClient);

package/src/store/runtime-clients/composer-runtime-client.ts

@@ -15,28 +15,30 @@ import type { QueueItemState } from "../scopes/queue-item";
 import { AttachmentRuntimeClient } from "./attachment-runtime-client";
 import { useSubscribable } from "./useSubscribable";
 
-const ComposerAttachmentClientByIndex = resource(
-  function ComposerAttachmentClientByIndex({
-    runtime,
-    index,
-  }: {
-    runtime: ComposerRuntime;
-    index: number;
-  }) {
-    const attachmentRuntime = useMemo(
-      () => runtime.getAttachmentByIndex(index),
-      [runtime, index],
-    );
+const useComposerAttachmentClientByIndex = ({
+  runtime,
+  index,
+}: {
+  runtime: ComposerRuntime;
+  index: number;
+}) => {
+  const attachmentRuntime = useMemo(
+    () => runtime.getAttachmentByIndex(index),
+    [runtime, index],
+  );
 
-    return useResource(
-      AttachmentRuntimeClient({
-        runtime: attachmentRuntime,
-      }),
-    );
-  },
+  return useResource(
+    AttachmentRuntimeClient({
+      runtime: attachmentRuntime,
+    }),
+  );
+};
+
+const ComposerAttachmentClientByIndex = resource(
+  useComposerAttachmentClientByIndex,
 );
 
-const QueueItemClient = resource(function QueueItemClient({
+const useQueueItemClient = ({
   item,
   onSteer,
   onRemove,
@@ -44,15 +46,17 @@ const QueueItemClient = resource(function QueueItemClient({
   item: QueueItemState;
   onSteer: () => void;
   onRemove: () => void;
-}): ClientOutput<"queueItem"> {
+}): ClientOutput<"queueItem"> => {
   return {
     getState: () => item,
     steer: onSteer,
     remove: onRemove,
   };
-});
+};
+
+const QueueItemClient = resource(useQueueItemClient);
 
-export const ComposerClient = resource(function ComposerClient({
+const useComposerClient = ({
   threadIdRef,
   messageIdRef,
   runtime,
@@ -60,7 +64,7 @@ export const ComposerClient = resource(function ComposerClient({
   threadIdRef: { current: string };
   messageIdRef?: { current: string };
   runtime: ComposerRuntime;
-}): ClientOutput<"composer"> {
+}): ClientOutput<"composer"> => {
   const runtimeState = useSubscribable(runtime);
   const emit = useAssistantEmit();
 
@@ -173,4 +177,6 @@ export const ComposerClient = resource(function ComposerClient({
     queueItem: (selector) => queueItems.get(selector),
     __internal_getRuntime: () => runtime,
   };
-});
+};
+
+export const ComposerClient = resource(useComposerClient);

package/src/store/runtime-clients/message-part-runtime-client.ts

@@ -3,11 +3,11 @@ import type { ClientOutput } from "@assistant-ui/store";
 import type { MessagePartRuntime } from "../../runtime/api/message-part-runtime";
 import { useSubscribable } from "./useSubscribable";
 
-export const MessagePartClient = resource(function MessagePartClient({
+const useMessagePartClient = ({
   runtime,
 }: {
   runtime: MessagePartRuntime;
-}): ClientOutput<"part"> {
+}): ClientOutput<"part"> => {
   const state = useSubscribable(runtime);
 
   return {
@@ -18,4 +18,6 @@ export const MessagePartClient = resource(function MessagePartClient({
       runtime.respondToToolApproval(response),
     __internal_getRuntime: () => runtime,
   };
-});
+};
+
+export const MessagePartClient = resource(useMessagePartClient);

package/src/store/runtime-clients/message-runtime-client.ts

@@ -12,43 +12,47 @@ import { MessagePartClient } from "./message-part-runtime-client";
 import type { MessageState } from "../scopes/message";
 import { AttachmentRuntimeClient } from "./attachment-runtime-client";
 
+const useMessageAttachmentClientByIndex = ({
+  runtime,
+  index,
+}: {
+  runtime: MessageRuntime;
+  index: number;
+}) => {
+  const attachmentRuntime = useMemo(
+    () => runtime.getAttachmentByIndex(index),
+    [runtime, index],
+  );
+  return useResource(AttachmentRuntimeClient({ runtime: attachmentRuntime }));
+};
+
 const MessageAttachmentClientByIndex = resource(
-  function MessageAttachmentClientByIndex({
-    runtime,
-    index,
-  }: {
-    runtime: MessageRuntime;
-    index: number;
-  }) {
-    const attachmentRuntime = useMemo(
-      () => runtime.getAttachmentByIndex(index),
-      [runtime, index],
-    );
-    return useResource(AttachmentRuntimeClient({ runtime: attachmentRuntime }));
-  },
+  useMessageAttachmentClientByIndex,
 );
 
-const MessagePartByIndex = resource(function MessagePartByIndex({
+const useMessagePartByIndex = ({
   runtime,
   index,
 }: {
   runtime: MessageRuntime;
   index: number;
-}) {
+}) => {
   const partRuntime = useMemo(
     () => runtime.getMessagePartByIndex(index),
     [runtime, index],
   );
   return useResource(MessagePartClient({ runtime: partRuntime }));
-});
+};
 
-export const MessageClient = resource(function MessageClient({
+const MessagePartByIndex = resource(useMessagePartByIndex);
+
+const useMessageClient = ({
   runtime,
   threadIdRef,
 }: {
   runtime: MessageRuntime;
   threadIdRef: { current: string };
-}): ClientOutput<"message"> {
+}): ClientOutput<"message"> => {
   const runtimeState = useSubscribable(runtime);
 
   const [isCopiedState, setIsCopied] = useState(false);
@@ -117,6 +121,7 @@ export const MessageClient = resource(function MessageClient({
 
     composer: () => composer.methods,
 
+    delete: () => runtime.delete(),
     reload: (config) => runtime.reload(config),
     speak: () => runtime.speak(),
     stopSpeaking: () => runtime.stopSpeaking(),
@@ -144,4 +149,6 @@ export const MessageClient = resource(function MessageClient({
 
     __internal_getRuntime: () => runtime,
   };
-});
+};
+
+export const MessageClient = resource(useMessageClient);

package/src/store/runtime-clients/thread-list-item-runtime-client.ts

@@ -8,11 +8,11 @@ import type {
 } from "../../runtime/api/thread-list-item-runtime";
 import { useSubscribable } from "./useSubscribable";
 
-export const ThreadListItemClient = resource(function ThreadListItemClient({
+const useThreadListItemClient = ({
   runtime,
 }: {
   runtime: ThreadListItemRuntime;
-}): ClientOutput<"threadListItem"> {
+}): ClientOutput<"threadListItem"> => {
   const state = useSubscribable(runtime);
   const emit = useAssistantEmit();
 
@@ -53,4 +53,6 @@ export const ThreadListItemClient = resource(function ThreadListItemClient({
     detach: runtime.detach,
     __internal_getRuntime: () => runtime,
   };
-});
+};
+
+export const ThreadListItemClient = resource(useThreadListItemClient);

package/src/store/runtime-clients/thread-list-runtime-client.ts

@@ -12,13 +12,13 @@ import { ThreadListItemClient } from "./thread-list-item-runtime-client";
 import { ThreadClient } from "./thread-runtime-client";
 import type { ThreadsState } from "../scopes/threads";
 
-const ThreadListItemClientById = resource(function ThreadListItemClientById({
+const useThreadListItemClientById = ({
   runtime,
   id,
 }: {
   runtime: ThreadListRuntime;
   id: string;
-}) {
+}) => {
   const threadListItemRuntime = useMemo(
     () => runtime.getItemById(id),
     [runtime, id],
@@ -28,15 +28,17 @@ const ThreadListItemClientById = resource(function ThreadListItemClientById({
       runtime: threadListItemRuntime,
     }),
   );
-});
+};
 
-export const ThreadListClient = resource(function ThreadListClient({
+const ThreadListItemClientById = resource(useThreadListItemClientById);
+
+const useThreadListClient = ({
   runtime,
   __internal_assistantRuntime,
 }: {
   runtime: ThreadListRuntime;
   __internal_assistantRuntime: AssistantRuntime;
-}): ClientOutput<"threads"> {
+}): ClientOutput<"threads"> => {
   const runtimeState = useSubscribable(runtime);
 
   const main = useClientResource(
@@ -96,4 +98,6 @@ export const ThreadListClient = resource(function ThreadListClient({
     loadMore: () => runtime.loadMore(),
     __internal_getAssistantRuntime: () => __internal_assistantRuntime,
   };
-});
+};
+
+export const ThreadListClient = resource(useThreadListClient);

package/src/store/runtime-clients/thread-runtime-client.ts

@@ -14,7 +14,7 @@ import { MessageClient } from "./message-runtime-client";
 import { useSubscribable } from "./useSubscribable";
 import type { ThreadState } from "../scopes/thread";
 
-const MessageClientById = resource(function MessageClientById({
+const useMessageClientById = ({
   runtime,
   id,
   threadIdRef,
@@ -22,20 +22,22 @@ const MessageClientById = resource(function MessageClientById({
   runtime: ThreadRuntime;
   id: string;
   threadIdRef: RefObject<string>;
-}) {
+}) => {
   const messageRuntime = useMemo(
     () => runtime.getMessageById(id),
     [runtime, id],
   );
 
   return useResource(MessageClient({ runtime: messageRuntime, threadIdRef }));
-});
+};
 
-export const ThreadClient = resource(function ThreadClient({
+const MessageClientById = resource(useMessageClientById);
+
+const useThreadClient = ({
   runtime,
 }: {
   runtime: ThreadRuntime;
-}): ClientOutput<"thread"> {
+}): ClientOutput<"thread"> => {
   const runtimeState = useSubscribable(runtime);
   const emit = useAssistantEmit();
 
@@ -109,6 +111,7 @@ export const ThreadClient = resource(function ThreadClient({
     getState: () => state,
     composer: () => composer.methods,
     append: runtime.append,
+    deleteMessage: runtime.deleteMessage,
     startRun: runtime.startRun,
     resumeRun: runtime.resumeRun,
     cancelRun: runtime.cancelRun,
@@ -132,4 +135,6 @@ export const ThreadClient = resource(function ThreadClient({
     },
     __internal_getRuntime: () => runtime,
   };
-});
+};
+
+export const ThreadClient = resource(useThreadClient);

package/src/store/scopes/message.ts

@@ -42,6 +42,7 @@ export type MessageMethods = {
    */
   getState(): MessageState;
   composer(): ComposerMethods;
+  delete(): void | Promise<void>;
   reload(config?: { runConfig?: RunConfig }): void;
   /** @deprecated This API is still under active development and might change without notice. */
   speak(): void;

package/src/store/scopes/thread-list-item.ts

@@ -6,6 +6,7 @@ export type ThreadListItemState = {
   readonly remoteId: string | undefined;
   readonly externalId: string | undefined;
   readonly title?: string | undefined;
+  readonly lastMessageAt?: Date | undefined;
   readonly status: ThreadListItemStatus;
   readonly custom?: Record<string, unknown> | undefined;
 };

package/src/store/scopes/thread.ts

@@ -88,6 +88,7 @@ export type ThreadMethods = {
    * ```
    */
   append(message: CreateAppendMessage): void;
+  deleteMessage(messageId: string): void | Promise<void>;
   /**
    * Start a new run with the given configuration.
    * @param config The configuration for starting the run

package/src/tests/external-store-thread-runtime-core.test.ts

@@ -49,6 +49,15 @@ describe("ExternalStoreThreadRuntimeCore - state reference stability", () => {
       expect(runtime.capabilities).not.toBe(capsBefore);
     });
 
+    it("enables delete when setMessages is provided", () => {
+      const runtime = new ExternalStoreThreadRuntimeCore(
+        mockContextProvider,
+        makeStore({ setMessages: vi.fn() }),
+      );
+
+      expect(runtime.capabilities.delete).toBe(true);
+    });
+
     it("should maintain stable reference across repeated setAdapter calls", () => {
       const runtime = new ExternalStoreThreadRuntimeCore(
         mockContextProvider,
@@ -152,6 +161,54 @@ describe("ExternalStoreThreadRuntimeCore - state reference stability", () => {
 
     expect(runtime.capabilities).toBe(capsBefore);
   });
+
+  describe("deleteMessage", () => {
+    it("removes only the selected message", async () => {
+      const setMessages = vi.fn();
+      const runtime = new ExternalStoreThreadRuntimeCore(
+        mockContextProvider,
+        makeStore({
+          messages: [
+            {
+              id: "u1",
+              role: "user",
+              content: [{ type: "text", text: "first" }],
+            },
+            {
+              id: "a1",
+              role: "assistant",
+              content: [{ type: "text", text: "answer" }],
+            },
+            {
+              id: "u2",
+              role: "user",
+              content: [{ type: "text", text: "second" }],
+            },
+          ],
+          setMessages,
+        }),
+      );
+
+      await runtime.deleteMessage("a1");
+
+      expect(setMessages).toHaveBeenCalledWith([
+        expect.objectContaining({ id: "u1" }),
+        expect.objectContaining({ id: "u2" }),
+      ]);
+    });
+
+    it("delegates to onDelete when provided", async () => {
+      const onDelete = vi.fn();
+      const runtime = new ExternalStoreThreadRuntimeCore(
+        mockContextProvider,
+        makeStore({ onDelete }),
+      );
+
+      await runtime.deleteMessage("m1");
+
+      expect(onDelete).toHaveBeenCalledWith("m1");
+    });
+  });
 });
 describe("ExternalStoreThreadRuntimeCore - optimistic message reconciliation", () => {
   type Raw = {