@dxos/plugin-thread 0.7.5-main.499c70c → 0.7.5-main.5ae2ba8

package/src/capabilities/intent-resolver.ts

@@ -0,0 +1,239 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import {
+  Capabilities,
+  contributes,
+  createIntent,
+  createResolver,
+  LayoutAction,
+  type PluginsContext,
+} from '@dxos/app-framework';
+import { Ref } from '@dxos/echo-schema';
+import { log } from '@dxos/log';
+import { ObservabilityAction } from '@dxos/plugin-observability/types';
+import { ChannelType, ThreadType } from '@dxos/plugin-space/types';
+import { create, fullyQualifiedId, getSpace, makeRef } from '@dxos/react-client/echo';
+
+import { ThreadCapabilities } from './capabilities';
+import { THREAD_PLUGIN } from '../meta';
+import { ThreadAction } from '../types';
+
+export default (context: PluginsContext) =>
+  contributes(Capabilities.IntentResolver, [
+    createResolver({
+      intent: ThreadAction.Create,
+      resolve: ({ name, cursor, subject }) => {
+        if (cursor && subject) {
+          // Seed the threads array if it does not exist.
+          if (subject?.threads === undefined) {
+            try {
+              // Static schema will throw an error if subject does not support threads array property.
+              subject.threads = [];
+            } catch (err) {
+              log.error('Subject does not support threads array', { typename: subject?.typename });
+              return;
+            }
+          }
+
+          const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+          const subjectId = fullyQualifiedId(subject);
+          const thread = create(ThreadType, { name, anchor: cursor, messages: [], status: 'staged' });
+          const draft = state.drafts[subjectId];
+          if (draft) {
+            draft.push(thread);
+          } else {
+            state.drafts[subjectId] = [thread];
+          }
+
+          return {
+            data: { object: thread },
+            intents: [
+              createIntent(ThreadAction.Select, { current: fullyQualifiedId(thread) }),
+              createIntent(LayoutAction.UpdateComplementary, { part: 'complementary', subject: 'comments' }),
+            ],
+          };
+        } else {
+          // TODO(wittjosiah): Create separate intent for channel creation.
+          return {
+            data: { object: create(ChannelType, { threads: [makeRef(create(ThreadType, { messages: [] }))] }) },
+          };
+        }
+      },
+    }),
+    createResolver({
+      intent: ThreadAction.Select,
+      resolve: ({ current, skipOpen }) => {
+        const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+        state.current = current;
+
+        return {
+          intents: !skipOpen
+            ? [createIntent(LayoutAction.UpdateComplementary, { part: 'complementary', subject: 'comments' })]
+            : undefined,
+        };
+      },
+    }),
+    createResolver({
+      intent: ThreadAction.ToggleResolved,
+      resolve: ({ thread }) => {
+        if (thread.status === 'active' || thread.status === undefined) {
+          thread.status = 'resolved';
+        } else if (thread.status === 'resolved') {
+          thread.status = 'active';
+        }
+
+        const space = getSpace(thread);
+        const spaceId = space?.id;
+
+        return {
+          intents: [
+            createIntent(ObservabilityAction.SendEvent, {
+              name: 'threads.toggle-resolved',
+              properties: { threadId: thread.id, spaceId },
+            }),
+          ],
+        };
+      },
+    }),
+    createResolver({
+      intent: ThreadAction.Delete,
+      resolve: ({ subject, thread }, undo) => {
+        const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+        const subjectId = fullyQualifiedId(subject);
+        const draft = state.drafts[subjectId];
+        if (draft) {
+          // Check if we're deleting a draft; if so, remove it.
+          const index = draft.findIndex((t) => t.id === thread.id);
+          if (index !== -1) {
+            draft.splice(index, 1);
+            return;
+          }
+        }
+
+        const space = getSpace(thread);
+        if (!space || !subject.threads) {
+          return;
+        }
+
+        if (!undo) {
+          const index = subject.threads.findIndex((t: any) => t?.id === thread.id);
+          const cursor = subject.threads[index]?.anchor;
+          if (index !== -1) {
+            subject.threads?.splice(index, 1);
+          }
+
+          space.db.remove(thread);
+
+          return {
+            undoable: {
+              message: ['thread deleted label', { ns: THREAD_PLUGIN }],
+              data: { cursor },
+            },
+            intents: [
+              createIntent(ObservabilityAction.SendEvent, {
+                name: 'threads.delete',
+                properties: { threadId: thread.id, spaceId: space.id },
+              }),
+            ],
+          };
+        } else {
+          // TODO(wittjosiah): SDK should do this automatically.
+          const savedThread = space.db.add(thread);
+          subject.threads.push(savedThread);
+
+          return {
+            intents: [
+              createIntent(ObservabilityAction.SendEvent, {
+                name: 'threads.undo-delete',
+                properties: { threadId: thread.id, spaceId: space.id },
+              }),
+            ],
+          };
+        }
+      },
+    }),
+    createResolver({
+      intent: ThreadAction.OnMessageAdd,
+      resolve: ({ thread, subject }) => {
+        const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+        const subjectId = fullyQualifiedId(subject);
+        const space = getSpace(subject);
+        const intents = [];
+        const analyticsProperties = { threadId: thread.id, spaceId: space?.id };
+
+        if (state.drafts[subjectId]?.find((t) => t === thread)) {
+          // Move draft to document.
+          thread.status = 'active';
+          subject.threads ? subject.threads.push(makeRef(thread)) : (subject.threads = [makeRef(thread)]);
+          state.drafts[subjectId] = state.drafts[subjectId]?.filter(({ id }) => id !== thread.id);
+          intents.push(
+            createIntent(ObservabilityAction.SendEvent, {
+              name: 'threads.thread-created',
+              properties: analyticsProperties,
+            }),
+          );
+        }
+
+        intents.push(
+          createIntent(ObservabilityAction.SendEvent, {
+            name: 'threads.message-added',
+            properties: { ...analyticsProperties, threadLength: thread.messages.length },
+          }),
+        );
+
+        return { intents };
+      },
+    }),
+    createResolver({
+      intent: ThreadAction.DeleteMessage,
+      resolve: ({ subject, thread, messageId, message, messageIndex }, undo) => {
+        const space = getSpace(subject);
+
+        if (!undo) {
+          const messageIndex = thread.messages.findIndex(Ref.hasObjectId(messageId));
+          const message = thread.messages[messageIndex]?.target;
+          if (!message) {
+            return;
+          }
+
+          if (messageIndex === 0 && thread.messages.length === 1) {
+            // If the message is the only message in the thread, delete the thread.
+            return {
+              intents: [createIntent(ThreadAction.Delete, { subject, thread })],
+            };
+          } else {
+            thread.messages.splice(messageIndex, 1);
+          }
+
+          return {
+            undoable: {
+              message: ['message deleted label', { ns: THREAD_PLUGIN }],
+              data: { message, messageIndex },
+            },
+            intents: [
+              createIntent(ObservabilityAction.SendEvent, {
+                name: 'threads.message.delete',
+                properties: { threadId: thread.id, spaceId: space?.id },
+              }),
+            ],
+          };
+        } else {
+          if (!messageIndex || !message) {
+            return;
+          }
+
+          thread.messages.splice(messageIndex, 0, makeRef(message));
+          return {
+            intents: [
+              createIntent(ObservabilityAction.SendEvent, {
+                name: 'threads.message.undo-delete',
+                properties: { threadId: thread.id, spaceId: space?.id },
+              }),
+            ],
+          };
+        }
+      },
+    }),
+  ]);

package/src/capabilities/markdown.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown';
+
+import { ThreadCapabilities } from './capabilities';
+import { threads } from '../extensions';
+
+export default (context: PluginsContext) =>
+  contributes(MarkdownCapabilities.Extensions, [
+    ({ document: doc }) => {
+      const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+      const { state } = context.requestCapability(ThreadCapabilities.MutableState);
+      return threads(state, doc, dispatch);
+    },
+  ]);

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,61 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { Capabilities, contributes, createSurface, useLayout } from '@dxos/app-framework';
+import { type Ref } from '@dxos/echo-schema';
+import { SettingsStore } from '@dxos/local-storage';
+import { ChannelType, type ThreadType } from '@dxos/plugin-space/types';
+import { getSpace } from '@dxos/react-client/echo';
+
+import { ThreadContainer, ThreadComplementary, ThreadSettings } from '../components';
+import { THREAD_PLUGIN } from '../meta';
+import { type ThreadSettingsProps } from '../types';
+
+export default () =>
+  contributes(Capabilities.ReactSurface, [
+    createSurface({
+      id: `${THREAD_PLUGIN}/channel`,
+      role: 'article',
+      filter: (data): data is { subject: ChannelType } =>
+        data.subject instanceof ChannelType && !!data.subject.threads[0],
+      component: ({ data, role }) => {
+        const layout = useLayout();
+        const channel = data.subject;
+        void channel.threads[0].load();
+        const thread = channel.threads[0].target;
+        if (!thread) {
+          return null;
+        }
+
+        const currentPosition = layout.active.findIndex((id) => id === channel.id);
+        if (currentPosition > 0) {
+          const objectToTheLeft = layout.active[currentPosition - 1];
+          const context = getSpace(channel)?.db.getObjectById(objectToTheLeft);
+          return <ThreadContainer role={role} thread={thread} context={context} />;
+        }
+
+        return <ThreadContainer role={role} thread={thread} />;
+      },
+    }),
+    createSurface({
+      id: `${THREAD_PLUGIN}/thread`,
+      role: 'complementary--comments',
+      filter: (data): data is { subject: { threads: Ref<ThreadType>[] } } =>
+        !!data.subject &&
+        typeof data.subject === 'object' &&
+        'threads' in data.subject &&
+        Array.isArray(data.subject.threads) &&
+        !(data.subject instanceof ChannelType),
+      component: ({ data }) => <ThreadComplementary subject={data.subject} />,
+    }),
+    createSurface({
+      id: `${THREAD_PLUGIN}/settings`,
+      role: 'article',
+      filter: (data): data is { subject: SettingsStore<ThreadSettingsProps> } =>
+        data.subject instanceof SettingsStore && data.subject.prefix === THREAD_PLUGIN,
+      component: ({ data: { subject } }) => <ThreadSettings settings={subject.value} />,
+    }),
+  ]);

package/src/capabilities/settings.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes } from '@dxos/app-framework';
+import { create } from '@dxos/live-object';
+
+import { THREAD_PLUGIN } from '../meta';
+import { type ThreadSettingsProps, ThreadSettingsSchema } from '../types';
+
+export default () => {
+  const settings = create<ThreadSettingsProps>({});
+  return contributes(Capabilities.Settings, { schema: ThreadSettingsSchema, prefix: THREAD_PLUGIN, value: settings });
+};

package/src/capabilities/state.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes } from '@dxos/app-framework';
+import { create } from '@dxos/live-object';
+
+import { ThreadCapabilities } from './capabilities';
+import { type ThreadState, type ViewStore } from '../types';
+
+const initialViewState = { showResolvedThreads: false };
+
+export default () => {
+  const state = create<ThreadState>({ drafts: {} });
+  const viewStore = create<ViewStore>({});
+
+  const getViewState = (subjectId: string) => {
+    if (!viewStore[subjectId]) {
+      viewStore[subjectId] = { ...initialViewState };
+    }
+    return viewStore[subjectId];
+  };
+
+  return contributes(ThreadCapabilities.State, { state, getViewState });
+};

package/src/components/Chat.stories.tsx

@@ -7,14 +7,14 @@ import '@dxos-theme';
 import { type Meta } from '@storybook/react';
 import React, { useEffect, useState } from 'react';
 
-import { createSurface, SurfaceProvider } from '@dxos/app-framework';
+import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
 import { MessageType, ThreadType } from '@dxos/plugin-space/types';
 import { faker } from '@dxos/random';
 import { useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
-import { ClientRepeater } from '@dxos/react-client/testing';
-import { Mosaic } from '@dxos/react-ui-mosaic';
+import { withClientProvider } from '@dxos/react-client/testing';
 import { Thread } from '@dxos/react-ui-thread';
 import { withLayout, withTheme } from '@dxos/storybook-utils';
 
@@ -46,24 +46,7 @@ const Story = () => {
   }
 
   return (
-    <SurfaceProvider
-      value={{
-        surfaces: {
-          ObjectMessage: createSurface({
-            id: 'test',
-            role: 'card',
-            component: ({ role }) => <span>{JSON.stringify({ role })}</span>,
-          }),
-        },
-      }}
-    >
-      <Mosaic.Root debug>
-        <main className='max-is-prose mli-auto bs-dvh overflow-hidden'>
-          {space && <ChatContainer thread={thread} />}
-        </main>
-        <Mosaic.DragOverlay />
-      </Mosaic.Root>
-    </SurfaceProvider>
+    <main className='max-is-prose mli-auto bs-dvh overflow-hidden'>{space && <ChatContainer thread={thread} />}</main>
   );
 };
 
@@ -72,9 +55,24 @@ export const Default = {};
 const meta: Meta = {
   title: 'plugins/plugin-thread/Chat',
   component: Thread,
-  // TODO(burdon): Use decorator.
-  render: () => <ClientRepeater component={Story} createIdentity createSpace types={[ThreadType, MessageType]} />,
-  decorators: [withTheme, withLayout({ fullscreen: true, tooltips: true })],
+  render: () => <Story />,
+  decorators: [
+    withPluginManager({
+      capabilities: [
+        contributes(
+          Capabilities.ReactSurface,
+          createSurface({
+            id: 'test',
+            role: 'card',
+            component: ({ role }) => <span>{JSON.stringify({ role })}</span>,
+          }),
+        ),
+      ],
+    }),
+    withTheme,
+    withLayout({ fullscreen: true, tooltips: true }),
+    withClientProvider({ createSpace: true, types: [ThreadType, MessageType] }),
+  ],
   parameters: { translations },
 };
 

package/src/components/ChatContainer.tsx

@@ -7,7 +7,7 @@ import React, { useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { Ref } from '@dxos/echo-schema';
 import { create, makeRef, RefArray } from '@dxos/live-object';
 import { MessageType } from '@dxos/plugin-space/types';
-import { fullyQualifiedId, getSpace, useMembers, type Expando } from '@dxos/react-client/echo';
+import { fullyQualifiedId, getSpace, useMembers } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { Icon, ScrollArea, useThemeContext, useTranslation } from '@dxos/react-ui';
 import { createBasicExtensions, createThemeExtensions, listener } from '@dxos/react-ui-editor';
@@ -82,7 +82,7 @@ export const ChatContainer = ({ thread, context, current, autoFocusTextbox }: Th
           sender: { identityKey: identity.identityKey.toHex() },
           timestamp: new Date().toISOString(),
           text: messageRef.current,
-          context: makeRef(context as Expando),
+          context: context ? makeRef(context) : undefined,
         }),
       ),
     );

package/src/components/CommentContainer.tsx

@@ -5,8 +5,7 @@
 import { CheckCircle, X } from '@phosphor-icons/react';
 import React, { useCallback, useMemo, useRef, useState } from 'react';
 
-import { create, makeRef, RefArray } from '@dxos/live-object';
-import { MessageType } from '@dxos/plugin-space/types';
+import { RefArray } from '@dxos/live-object';
 import { fullyQualifiedId, getSpace, useMembers } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { Button, Tag, Tooltip, useThemeContext, useTranslation } from '@dxos/react-ui';
@@ -19,7 +18,7 @@ import {
   mx,
 } from '@dxos/react-ui-theme';
 import { MessageTextbox, type MessageTextboxProps, Thread, ThreadFooter, ThreadHeading } from '@dxos/react-ui-thread';
-import { nonNullable } from '@dxos/util';
+import { isNonNullable } from '@dxos/util';
 
 import { MessageContainer } from './MessageContainer';
 import { command } from './command-extension';
@@ -94,13 +93,12 @@ const DeleteThreadButton = ({ onDelete }: { onDelete: () => void }) => {
 export const CommentContainer = ({
   thread,
   detached,
-  context,
   current,
   onAttend,
-  onThreadDelete,
-  onMessageDelete,
-  onResolve,
   onComment,
+  onResolve,
+  onMessageDelete,
+  onThreadDelete,
 }: ThreadContainerProps) => {
   const identity = useIdentity()!;
   const space = getSpace(thread);
@@ -129,33 +127,26 @@ export const CommentContainer = ({
   const scrollToEnd = (behavior: ScrollBehavior) =>
     setTimeout(() => threadScrollRef.current?.scrollIntoView({ behavior, block: 'end' }), 10);
 
-  const handleCreate: MessageTextboxProps['onSend'] = useCallback(() => {
+  const handleAttend = useCallback(() => onAttend?.(thread), [onAttend, thread]);
+  const handleResolve = useCallback(() => onResolve?.(thread), [onResolve, thread]);
+  const handleMessageDelete = useCallback((id: string) => onMessageDelete?.(thread, id), [onMessageDelete, thread]);
+  const handleThreadDelete = useCallback(() => onThreadDelete?.(thread), [onThreadDelete, thread]);
+
+  const handleComment: MessageTextboxProps['onSend'] = useCallback(() => {
     if (!messageRef.current) {
       return false;
     }
 
-    thread.messages.push(
-      makeRef(
-        create(MessageType, {
-          sender: { identityKey: identity.identityKey.toHex() },
-          timestamp: new Date().toISOString(),
-          text: messageRef.current,
-          context: context ? makeRef(context) : undefined,
-        }),
-      ),
-    );
-    onComment?.(thread);
-
+    onComment?.(thread, messageRef.current);
     messageRef.current = '';
     scrollToEnd('instant');
     rerenderEditor();
 
-    // TODO(burdon): Scroll to bottom.
     return true;
   }, [thread, identity]);
 
   return (
-    <Thread onClickCapture={onAttend} onFocusCapture={onAttend} current={current} id={fullyQualifiedId(thread)}>
+    <Thread onClickCapture={handleAttend} onFocusCapture={handleAttend} current={current} id={fullyQualifiedId(thread)}>
       <div
         role='none'
         className={mx(
@@ -182,19 +173,14 @@ export const CommentContainer = ({
         <div className='flex flex-row items-center pli-1'>
           {thread.status === 'staged' && <Tag palette='neutral'>{t('draft button')}</Tag>}
           {onResolve && !(thread?.status === 'staged') && (
-            <ToggleResolvedButton isResolved={thread?.status === 'resolved'} onResolve={onResolve} />
+            <ToggleResolvedButton isResolved={thread?.status === 'resolved'} onResolve={handleResolve} />
           )}
-          {onThreadDelete && <DeleteThreadButton onDelete={onThreadDelete} />}
+          {onThreadDelete && <DeleteThreadButton onDelete={handleThreadDelete} />}
         </div>
       </div>
       {/** TODO(dmaretskyi): How's `thread.messages` undefined? */}
-      {RefArray.allResolvedTargets(thread.messages?.filter(nonNullable) ?? []).map((message) => (
-        <MessageContainer
-          key={message.id}
-          message={message}
-          members={members}
-          onDelete={(id: string) => onMessageDelete?.(id)}
-        />
+      {RefArray.allResolvedTargets(thread.messages?.filter(isNonNullable) ?? []).map((message) => (
+        <MessageContainer key={message.id} message={message} members={members} onDelete={handleMessageDelete} />
       ))}
       {/*
         TODO(wittjosiah): Can't autofocus this generally.
@@ -202,7 +188,7 @@ export const CommentContainer = ({
           Also, it steals focus from documents when first rendered.
           Need to find a way to autofocus in one scenario only: when a new thread is created.
       */}
-      <MessageTextbox extensions={extensions} onSend={handleCreate} {...textboxMetadata} />
+      <MessageTextbox extensions={extensions} onSend={handleComment} {...textboxMetadata} />
       <ThreadFooter activity={activity}>{t('activity message')}</ThreadFooter>
       {/* NOTE(thure): This can’t also be the `overflow-anchor` because `ScrollArea` injects an interceding node that contains this necessary ref’d element. */}
       <div role='none' className='bs-px -mbs-px' ref={threadScrollRef} />

package/src/components/Comments.stories.tsx

@@ -7,6 +7,8 @@ import '@dxos-theme';
 import { type Meta } from '@storybook/react';
 import React, { useEffect, useState } from 'react';
 
+import { IntentPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
 import { MessageType, ThreadType } from '@dxos/plugin-space/types';
 import { faker } from '@dxos/random';
 import { Filter, fullyQualifiedId, useQuery, useSpace } from '@dxos/react-client/echo';
@@ -44,7 +46,7 @@ const Story = ({ spaceKey }: ClientRepeatedComponentProps) => {
 
   return (
     <div className='flex justify-center overflow-y-auto bg-white dark:bg-black'>
-      <div className='flex flex-col w-[400px]'>
+      <div className='flex flex-col w-[30rem]'>
         <CommentsContainer threads={threads} detached={detached} onThreadDelete={console.log} />
       </div>
     </div>
@@ -57,7 +59,11 @@ const meta: Meta = {
   title: 'plugins/plugin-thread/Comments',
   // TODO(wittjosiah): Use decorator.
   render: () => <ClientRepeater component={Story} createIdentity createSpace types={[ThreadType, MessageType]} />,
-  decorators: [withTheme, withLayout({ fullscreen: true, tooltips: true })],
+  decorators: [
+    withTheme,
+    withLayout({ fullscreen: true, tooltips: true }),
+    withPluginManager({ plugins: [IntentPlugin()] }),
+  ],
   parameters: { translations },
 };
 

package/src/components/CommentsContainer.tsx

@@ -14,10 +14,7 @@ import { CommentContainer } from './CommentContainer';
 import { type ThreadContainerProps } from './types';
 import { THREAD_PLUGIN } from '../meta';
 
-export type ThreadsContainerProps = Omit<
-  ThreadContainerProps,
-  'thread' | 'detached' | 'onAttend' | 'onThreadDelete' | 'onMessageDelete' | 'current' | 'autoFocus'
-> & {
+export type ThreadsContainerProps = Omit<ThreadContainerProps, 'thread' | 'detached' | 'current' | 'autoFocus'> & {
   threads: ThreadType[];
   /**
    * Threads that are no longer anchored to a position in the object.
@@ -25,11 +22,6 @@ export type ThreadsContainerProps = Omit<
   detached?: string[];
   currentId?: string;
   showResolvedThreads?: boolean;
-  onThreadAttend?: (thread: ThreadType) => void;
-  onThreadDelete?: (thread: ThreadType) => void;
-  onMessageDelete?: (thread: ThreadType, messageId: string) => void;
-  onThreadToggleResolved?: (thread: ThreadType) => void;
-  onComment?: (thread: ThreadType) => void;
 };
 
 /**
@@ -40,10 +32,6 @@ export const CommentsContainer = ({
   detached = [],
   currentId,
   showResolvedThreads,
-  onThreadAttend,
-  onThreadDelete,
-  onMessageDelete,
-  onThreadToggleResolved,
   ...props
 }: ThreadsContainerProps) => {
   const { t } = useTranslation(THREAD_PLUGIN);
@@ -66,10 +54,6 @@ export const CommentsContainer = ({
               thread={thread}
               current={currentId === threadId}
               detached={detached.includes(threadId)}
-              {...(onThreadAttend && { onAttend: () => onThreadAttend(thread) })}
-              {...(onThreadDelete && { onThreadDelete: () => onThreadDelete(thread) })}
-              {...(onMessageDelete && { onMessageDelete: (messageId: string) => onMessageDelete(thread, messageId) })}
-              {...(onThreadToggleResolved && { onResolve: () => onThreadToggleResolved(thread) })}
               {...props}
             />
           );