@dxos/plugin-assistant 0.8.2-staging.7ac8446 → 0.8.2

package/src/capabilities/app-graph-builder.ts

@@ -2,194 +2,232 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Rx } from '@effect-rx/rx-react';
+import { Option, pipe } from 'effect';
+
 import {
   Capabilities,
   contributes,
   createIntent,
   LayoutAction,
   type PromiseIntentDispatcher,
-  type PluginsContext,
+  type PluginContext,
 } from '@dxos/app-framework';
+import { isInstanceOf } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { PLANK_COMPANION_TYPE, ATTENDABLE_PATH_SEPARATOR, DECK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { createExtension, type Node, ROOT_ID } from '@dxos/plugin-graph';
-import { memoizeQuery } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
+import { PLANK_COMPANION_TYPE, ATTENDABLE_PATH_SEPARATOR } from '@dxos/plugin-deck/types';
+import { createExtension, ROOT_ID } from '@dxos/plugin-graph';
+import { rxFromQuery } from '@dxos/plugin-space';
+import { SPACE_TYPE, SpaceAction } from '@dxos/plugin-space/types';
 import {
   type Space,
   Filter,
   fullyQualifiedId,
   getSpace,
   isSpace,
-  isReactiveObject,
-  parseId,
+  Query,
+  type QueryResult,
+  isEchoObject,
 } from '@dxos/react-client/echo';
 
 import { ASSISTANT_DIALOG, ASSISTANT_PLUGIN } from '../meta';
-import { AIChatType, AssistantAction, TemplateType } from '../types';
+import { AIChatType, AssistantAction, CompanionTo, TemplateType } from '../types';
 
-export default (context: PluginsContext) =>
+export default (context: PluginContext) =>
   contributes(Capabilities.AppGraphBuilder, [
     createExtension({
       id: `${ASSISTANT_PLUGIN}/assistant`,
-      filter: (node): node is Node<null> => node.id === ROOT_ID,
-      actions: () => [
-        {
-          id: `${LayoutAction.UpdateDialog._tag}/assistant/open`,
-          data: async () => {
-            const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-            const client = context.requestCapability(ClientCapabilities.Client);
-            const layout = context.requestCapability(Capabilities.Layout);
-            const { graph } = context.requestCapability(Capabilities.AppGraph);
+      actions: (node) =>
+        Rx.make((get) =>
+          pipe(
+            get(node),
+            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
+            Option.map(() => [
+              {
+                id: `${LayoutAction.UpdateDialog._tag}/assistant/open`,
+                data: async () => {
+                  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+                  const client = context.getCapability(ClientCapabilities.Client);
+                  const layout = context.getCapability(Capabilities.Layout);
+                  const { graph } = context.getCapability(Capabilities.AppGraph);
 
-            // TODO(burdon): Get space from workspace.
-            // TODO(burdon): If need to create chat, then add to dispatch stack below.
-            let chat: AIChatType | undefined;
-            if (layout.active.length > 0) {
-              const node = graph.findNode(layout.active[0]);
-              if (node) {
-                const space = getSpace(node.data);
-                if (space) {
-                  chat = await getOrCreateChat(dispatch, space);
-                }
-              }
-            } else {
-              const space = client.spaces.default;
-              chat = await getOrCreateChat(dispatch, space);
-            }
+                  // TODO(burdon): Get space from workspace.
+                  // TODO(burdon): If need to create chat, then add to dispatch stack below.
+                  let chat: AIChatType | undefined;
+                  if (layout.active.length > 0) {
+                    const node = graph.getNode(layout.active[0]).pipe(Option.getOrNull);
+                    if (node) {
+                      const space = getSpace(node.data);
+                      if (space) {
+                        chat = await getOrCreateChat(dispatch, space);
+                      }
+                    }
+                  } else {
+                    const space = client.spaces.default;
+                    chat = await getOrCreateChat(dispatch, space);
+                  }
 
-            if (!chat) {
-              return;
-            }
+                  if (!chat) {
+                    return;
+                  }
 
-            await dispatch(
-              createIntent(LayoutAction.UpdateDialog, {
-                part: 'dialog',
-                subject: ASSISTANT_DIALOG,
-                options: {
-                  state: true,
-                  blockAlign: 'end',
-                  props: {
-                    chat,
+                  await dispatch(
+                    createIntent(LayoutAction.UpdateDialog, {
+                      part: 'dialog',
+                      subject: ASSISTANT_DIALOG,
+                      options: {
+                        state: true,
+                        blockAlign: 'end',
+                        props: {
+                          chat,
+                        },
+                      },
+                    }),
+                  );
+                },
+                properties: {
+                  label: ['open assistant label', { ns: ASSISTANT_PLUGIN }],
+                  icon: 'ph--sparkle--regular',
+                  disposition: 'pin-end',
+                  position: 'hoist',
+                  keyBinding: {
+                    macos: 'shift+meta+k',
+                    windows: 'shift+ctrl+k',
                   },
                 },
-              }),
-            );
-          },
-          properties: {
-            label: ['open assistant label', { ns: ASSISTANT_PLUGIN }],
-            icon: 'ph--star-four--regular',
-            disposition: 'pin-end',
-            position: 'hoist',
-            keyBinding: {
-              macos: 'shift+meta+k',
-              windows: 'shift+ctrl+k',
-            },
-          },
-        },
-      ],
+              },
+            ]),
+            Option.getOrElse(() => []),
+          ),
+        ),
     }),
 
     createExtension({
-      id: `${ASSISTANT_PLUGIN}/service-registry`,
-      filter: (node): node is Node<null> => node.id === 'root',
-      connector: ({ node }) => {
-        const layout = context.requestCapability(Capabilities.Layout);
-        const client = context.requestCapability(ClientCapabilities.Client);
-        const { spaceId } = parseId(layout.workspace);
-        const space = spaceId ? client.spaces.get(spaceId) : null;
+      id: `${ASSISTANT_PLUGIN}/object-chat-companion`,
+      connector: (node) => {
+        let query: QueryResult<AIChatType> | undefined;
+        return Rx.make((get) =>
+          pipe(
+            get(node),
+            Option.flatMap((node) => (isEchoObject(node.data) ? Option.some(node.data) : Option.none())),
+            Option.flatMap((object) => {
+              const space = getSpace(object);
+              return space ? Option.some({ space, object }) : Option.none();
+            }),
+            Option.map(({ space, object }) => {
+              if (!query) {
+                query = space.db.query(Query.select(Filter.ids(object.id)).targetOf(CompanionTo).source());
+              }
 
-        return [
-          {
-            id: [node.id, 'service-registry'].join(ATTENDABLE_PATH_SEPARATOR),
-            type: DECK_COMPANION_TYPE,
-            data: space,
-            properties: {
-              label: ['service registry label', { ns: ASSISTANT_PLUGIN }],
-              icon: 'ph--plugs--regular',
-              disposition: 'hidden',
-            },
-          },
-        ];
+              const chat = get(rxFromQuery(query))[0];
+              return [
+                {
+                  id: [fullyQualifiedId(object), 'assistant-chat'].join(ATTENDABLE_PATH_SEPARATOR),
+                  type: PLANK_COMPANION_TYPE,
+                  data: chat ?? 'assistant-chat',
+                  properties: {
+                    label: ['assistant chat label', { ns: ASSISTANT_PLUGIN }],
+                    icon: 'ph--sparkle--regular',
+                    position: 'hoist',
+                    disposition: 'hidden',
+                  },
+                },
+              ];
+            }),
+            Option.getOrElse(() => []),
+          ),
+        );
       },
     }),
 
-    createExtension({
-      id: `${ASSISTANT_PLUGIN}/object-chat-companion`,
-      filter: (node): node is Node<AIChatType> =>
-        isReactiveObject(node.data) && node.data.assistantChatQueue && node.data.type !== AIChatType.typename,
-      connector: ({ node }) => [
-        {
-          id: [node.id, 'assistant-chat'].join(ATTENDABLE_PATH_SEPARATOR),
-          type: PLANK_COMPANION_TYPE,
-          data: 'assistant-chat',
-          properties: {
-            label: ['assistant chat label', { ns: ASSISTANT_PLUGIN }],
-            icon: 'ph--star-four--regular',
-            position: 'hoist',
-          },
-        },
-      ],
-    }),
-
     createExtension({
       id: `${ASSISTANT_PLUGIN}/root`,
-      filter: (node): node is Node<Space> => isSpace(node.data),
-      connector: ({ node }) => {
-        const templates = memoizeQuery(node.data, Filter.schema(TemplateType));
-        return templates.length > 0
-          ? [
-              {
-                id: `${ASSISTANT_PLUGIN}/templates`,
-                type: `${ASSISTANT_PLUGIN}/templates`,
-                data: null,
-                properties: {
-                  label: ['templates label', { ns: ASSISTANT_PLUGIN }],
-                  icon: 'ph--file-code--regular',
-                  space: node.data,
-                },
-              },
-            ]
-          : [];
+      connector: (node) => {
+        let query: QueryResult<TemplateType> | undefined;
+        return Rx.make((get) =>
+          pipe(
+            get(node),
+            Option.flatMap((node) =>
+              node.type === SPACE_TYPE && isSpace(node.data) ? Option.some(node.data) : Option.none(),
+            ),
+            Option.map((space) => {
+              if (!query) {
+                query = space.db.query(Query.type(TemplateType));
+              }
+
+              const templates = get(rxFromQuery(query));
+              return templates.length > 0
+                ? [
+                    {
+                      id: `${ASSISTANT_PLUGIN}/templates`,
+                      type: `${ASSISTANT_PLUGIN}/templates`,
+                      data: null,
+                      properties: {
+                        label: ['templates label', { ns: ASSISTANT_PLUGIN }],
+                        icon: 'ph--file-code--regular',
+                        space,
+                      },
+                    },
+                  ]
+                : [];
+            }),
+            Option.getOrElse(() => []),
+          ),
+        );
       },
     }),
 
     createExtension({
       id: `${ASSISTANT_PLUGIN}/templates`,
-      filter: (node): node is Node<null, { space: Space }> => node.id === `${ASSISTANT_PLUGIN}/templates`,
-      connector: ({ node }) => {
-        const templates = memoizeQuery(node.properties.space, Filter.schema(TemplateType));
-        return templates
-          .toSorted((a, b) => {
-            const nameA = a.name ?? '';
-            const nameB = b.name ?? '';
-            return nameA.localeCompare(nameB);
-          })
-          .map((template) => ({
-            id: fullyQualifiedId(template),
-            type: `${ASSISTANT_PLUGIN}/template`,
-            data: template,
-            properties: {
-              label: template.name ?? ['template title placeholder', { ns: ASSISTANT_PLUGIN }],
-              icon: 'ph--file-code--regular',
-            },
-          }));
+      connector: (node) => {
+        let query: QueryResult<TemplateType> | undefined;
+        return Rx.make((get) =>
+          pipe(
+            get(node),
+            Option.flatMap((node) =>
+              node.id === `${ASSISTANT_PLUGIN}/templates` && isSpace(node.properties.space)
+                ? Option.some(node.properties.space)
+                : Option.none(),
+            ),
+            Option.map((space) => {
+              if (!query) {
+                query = space.db.query(Query.type(TemplateType));
+              }
+              return get(rxFromQuery(query))
+                .toSorted((a, b) => {
+                  const nameA = a.name ?? '';
+                  const nameB = b.name ?? '';
+                  return nameA.localeCompare(nameB);
+                })
+                .map((template) => ({
+                  id: fullyQualifiedId(template),
+                  type: `${ASSISTANT_PLUGIN}/template`,
+                  data: template,
+                  properties: {
+                    label: template.name ?? ['object placeholder', { ns: ASSISTANT_PLUGIN }],
+                    icon: 'ph--file-code--regular',
+                  },
+                }));
+            }),
+            Option.getOrElse(() => []),
+          ),
+        );
       },
     }),
   ]);
 
 // TODO(burdon): Factor out.
 const getOrCreateChat = async (dispatch: PromiseIntentDispatcher, space: Space): Promise<AIChatType | undefined> => {
-  const { objects } = await space.db.query(Filter.schema(AIChatType)).run();
+  const { objects } = await space.db.query(Filter.type(AIChatType)).run();
   // console.log('objects', JSON.stringify(objects, null, 2));
   if (objects.length > 0) {
     // TODO(burdon): Is this the most recent?
     return objects[objects.length - 1];
   }
 
-  const { data } = await dispatch(createIntent(AssistantAction.CreateChat, { spaceId: space.id }));
-  invariant(data?.object instanceof AIChatType);
+  const { data } = await dispatch(createIntent(AssistantAction.CreateChat, { space }));
+  invariant(isInstanceOf(AIChatType, data?.object));
   await dispatch(createIntent(SpaceAction.AddObject, { target: space, object: data.object }));
   return data.object;
 };

package/src/capabilities/capabilities.ts

@@ -4,8 +4,8 @@
 
 import { type ReadonlySignal } from '@preact/signals-core';
 
+import { type AIServiceClient } from '@dxos/ai';
 import { defineCapability } from '@dxos/app-framework';
-import { type AIServiceClient } from '@dxos/assistant';
 
 import { ASSISTANT_PLUGIN } from '../meta';
 

package/src/capabilities/index.ts

@@ -8,6 +8,6 @@ export const AiClient = lazy(() => import('./ai-client'));
 export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
 export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const ReactSurface = lazy(() => import('./react-surface'));
-export const AssistantSettings = lazy(() => import('./settings'));
+export const Settings = lazy(() => import('./settings'));
 
 export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -3,9 +3,8 @@
 //
 
 import { Capabilities, contributes, createResolver } from '@dxos/app-framework';
-import { ObjectId } from '@dxos/echo-schema';
-import { DXN, QueueSubspaceTags } from '@dxos/keys';
-import { create, refFromDXN } from '@dxos/live-object';
+import { createQueueDxn } from '@dxos/echo-schema';
+import { live, refFromDXN } from '@dxos/live-object';
 
 import { AssistantAction, AIChatType, TemplateType } from '../types';
 
@@ -14,12 +13,11 @@ export default () => [
     Capabilities.IntentResolver,
     createResolver({
       intent: AssistantAction.CreateChat,
-      resolve: ({ spaceId, name }) => ({
+      resolve: ({ space, name }) => ({
         data: {
-          object: create(AIChatType, {
-            assistantChatQueue: refFromDXN(
-              new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, spaceId, ObjectId.random()]),
-            ),
+          object: live(AIChatType, {
+            name,
+            queue: refFromDXN(createQueueDxn(space.id)),
           }),
         },
       }),
@@ -31,7 +29,7 @@ export default () => [
       intent: AssistantAction.CreateTemplate,
       resolve: ({ name }) => ({
         data: {
-          object: create(TemplateType, { name, kind: { include: 'manual' }, source: '{{! Template }}' }),
+          object: live(TemplateType, { name, kind: { include: 'manual' }, source: '{{! Template }}' }),
         },
       }),
     }),

package/src/capabilities/react-surface.tsx

@@ -2,17 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useMemo } from 'react';
+import { Effect } from 'effect';
+import React, { useEffect, useMemo } from 'react';
 
-import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { isInstanceOf } from '@dxos/echo-schema';
-import { getTypename } from '@dxos/live-object';
+import { Capabilities, contributes, createIntent, createSurface, useIntentDispatcher } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+import { Filter, isInstanceOf, Query } from '@dxos/echo-schema';
 import { SettingsStore } from '@dxos/local-storage';
-import { fullyQualifiedId, isReactiveObject, isSpace, type Space } from '@dxos/react-client/echo';
+import { SpaceAction } from '@dxos/plugin-space/types';
+import {
+  type AnyLiveObject,
+  fullyQualifiedId,
+  getSpace,
+  getTypename,
+  isEchoObject,
+  type SpaceId,
+} from '@dxos/react-client/echo';
 
-import { AssistantDialog, AssistantSettings, ChatContainer, ServiceRegistry, TemplateContainer } from '../components';
+import { AssistantDialog, AssistantSettings, ChatContainer, PromptSettings, TemplateContainer } from '../components';
 import { ASSISTANT_PLUGIN, ASSISTANT_DIALOG } from '../meta';
-import { AIChatType, type AssistantSettingsProps, TemplateType } from '../types';
+import { AIChatType, AssistantAction, type AssistantSettingsProps, CompanionTo, TemplateType } from '../types';
 
 export default () =>
   contributes(Capabilities.ReactSurface, [
@@ -33,35 +42,73 @@ export default () =>
       id: `${ASSISTANT_PLUGIN}/chat`,
       role: 'article',
       filter: (data): data is { subject: AIChatType; variant: undefined } =>
-        isInstanceOf(AIChatType, data.subject) && data.variant !== 'assistant-chat',
+        Obj.instanceOf(AIChatType, data.subject) && data.variant !== 'assistant-chat',
       component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
     }),
     createSurface({
       id: `${ASSISTANT_PLUGIN}/object-chat`,
       role: 'article',
-      filter: (data): data is { companionTo: AIChatType; subject: 'assistant-chat' } =>
-        isReactiveObject(data.companionTo) && data.companionTo.assistantChatQueue && data.subject === 'assistant-chat',
+      filter: (data): data is { companionTo: AnyLiveObject<any>; subject: AIChatType | 'assistant-chat' } =>
+        isEchoObject(data.companionTo) && (isInstanceOf(AIChatType, data.subject) || data.subject === 'assistant-chat'),
       component: ({ data, role }) => {
+        const { dispatch } = useIntentDispatcher();
         const associatedArtifact = useMemo(
           () => ({
             id: fullyQualifiedId(data.companionTo),
             typename: getTypename(data.companionTo) ?? 'unknown',
+            spaceId: (getSpace(data.companionTo)?.id ?? 'unknown') as SpaceId,
           }),
           [data.companionTo],
         );
-        return <ChatContainer role={role} chat={data.companionTo} associatedArtifact={associatedArtifact} />;
+
+        // TODO(wittjosiah): Factor out to container.
+        useEffect(() => {
+          const timeout = setTimeout(async () => {
+            const space = getSpace(data.companionTo);
+            if (space && data.subject === 'assistant-chat') {
+              const result = await space.db
+                .query(Query.select(Filter.ids(data.companionTo.id)).targetOf(CompanionTo).source())
+                .run();
+              if (result.objects.length > 0) {
+                return;
+              }
+
+              const program = Effect.gen(function* () {
+                const { object } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
+                yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
+                yield* dispatch(
+                  createIntent(SpaceAction.AddRelation, {
+                    space,
+                    schema: CompanionTo,
+                    source: object,
+                    target: data.companionTo,
+                  }),
+                );
+              });
+              void Effect.runPromise(program);
+            }
+          });
+
+          return () => clearTimeout(timeout);
+        }, [data.subject]);
+
+        if (data.subject === 'assistant-chat') {
+          return null;
+        }
+
+        return <ChatContainer role={role} chat={data.subject} associatedArtifact={associatedArtifact} />;
       },
     }),
     createSurface({
       id: `${ASSISTANT_PLUGIN}/template`,
       role: 'article',
-      filter: (data): data is { subject: TemplateType } => isInstanceOf(TemplateType, data.subject),
+      filter: (data): data is { subject: TemplateType } => Obj.instanceOf(TemplateType, data.subject),
       component: ({ data, role }) => <TemplateContainer role={role} template={data.subject} />,
     }),
     createSurface({
-      id: `${ASSISTANT_PLUGIN}/service-registry`,
-      role: 'deck-companion--service-registry',
-      filter: (data): data is { subject: Space } => isSpace(data.subject),
-      component: ({ data }) => <ServiceRegistry space={data.subject} />,
+      id: `${ASSISTANT_PLUGIN}/prompt-settings`,
+      role: 'object-settings',
+      filter: (data): data is { subject: TemplateType } => Obj.instanceOf(TemplateType, data.subject),
+      component: ({ data }) => <PromptSettings template={data.subject} />,
     }),
   ]);

package/src/capabilities/settings.ts

@@ -3,13 +3,13 @@
 //
 
 import { Capabilities, contributes } from '@dxos/app-framework';
-import { create } from '@dxos/live-object';
+import { live } from '@dxos/live-object';
 
 import { ASSISTANT_PLUGIN } from '../meta';
 import { type AssistantSettingsProps, AssistantSettingsSchema } from '../types';
 
 export default () => {
-  const settings = create<AssistantSettingsProps>({});
+  const settings = live<AssistantSettingsProps>({});
 
   return contributes(Capabilities.Settings, {
     schema: AssistantSettingsSchema,

package/src/components/AmbientDialog/AmbientDialog.stories.tsx

@@ -19,7 +19,7 @@ import { AmbientDialog } from './AmbientDialog';
 import translations from '../../translations';
 
 const meta: Meta<typeof AmbientDialog> = {
-  title: 'plugins/plugin-automation/AmbientDialog',
+  title: 'plugins/plugin-assistant/AmbientDialog',
   component: AmbientDialog,
   render: () => {
     const [open, setOpen] = useState(true);
@@ -69,7 +69,7 @@ const meta: Meta<typeof AmbientDialog> = {
       plugins: [IntentPlugin()],
     }),
     withTheme,
-    withLayout({ fullscreen: true, tooltips: true }),
+    withLayout({ fullscreen: true }),
   ],
   parameters: {
     translations,

package/src/components/AmbientDialog/AmbientDialog.tsx

@@ -15,10 +15,19 @@ const minSize = 5;
 export type AmbientDialogProps = PropsWithChildren<{
   open?: boolean;
   title?: string;
+  resizeable?: boolean;
   onOpenChange?: (open: boolean) => void;
+  onEscape?: () => void;
 }>;
 
-export const AmbientDialog = ({ children, open: controlledOpen, title, onOpenChange }: AmbientDialogProps) => {
+export const AmbientDialog = ({
+  children,
+  open: controlledOpen,
+  title,
+  resizeable = true,
+  onOpenChange,
+  onEscape,
+}: AmbientDialogProps) => {
   const [resizeKey, setReizeKey] = useState(0);
   const [size, setSize] = useState<Size>('min-content');
   const [open, setOpen] = useState(controlledOpen);
@@ -47,26 +56,31 @@ export const AmbientDialog = ({ children, open: controlledOpen, title, onOpenCha
   return (
     <div role='none' className='dx-dialog__overlay bg-transparent pointer-events-none' data-block-align='end'>
       <Dialog.Content
-        classNames='relative box-content py-0 px-2 md:is-[35rem] md:max-is-none overflow-hidden pointer-events-auto transition-[block-size] ease-in-out duration-0 [&:not([data-dx-resizing="true"])]:duration-200'
+        classNames='relative box-content p-0 md:is-[35rem] md:max-is-none overflow-hidden pointer-events-auto transition-[block-size] ease-in-out duration-0 [&:not([data-dx-resizing="true"])]:duration-200'
         inOverlayLayout
         {...resizeAttributes}
         style={{
-          ...sizeStyle(size, 'vertical', true),
+          ...(resizeable ? sizeStyle(size, 'vertical', true) : {}),
           maxBlockSize: 'calc(100dvh - env(safe-area-inset-bottom) - env(safe-area-inset-top) - 9rem)',
         }}
+        onEscapeKeyDown={onEscape}
         onInteractOutside={preventDefault}
       >
-        <ResizeHandle
-          key={resizeKey}
-          side='block-start'
-          defaultSize='min-content'
-          minSize={minSize}
-          fallbackSize={minSize}
-          iconPosition='center'
-          onSizeChange={setSize}
-        />
+        {(resizeable && (
+          <>
+            <ResizeHandle
+              key={resizeKey}
+              side='block-start'
+              defaultSize='min-content'
+              minSize={minSize}
+              fallbackSize={minSize}
+              iconPosition='center'
+              onSizeChange={setSize}
+            />
 
-        <DialogHeader open={open} title={title} onToggle={handleToggle} />
+            <DialogHeader open={open} title={title} onToggle={handleToggle} />
+          </>
+        )) || <Dialog.Title srOnly />}
 
         {children}
       </Dialog.Content>

package/src/components/AssistantDialog.tsx

@@ -24,10 +24,10 @@ export const AssistantDialog: FC<{ chat?: AIChatType }> = ({ chat }) => {
   return (
     <AmbientDialog open={open} onOpenChange={setOpen} title={t('assistant dialog title')}>
       <ThreadContainer
+        part={'dialog'}
         chat={chat}
         onOpenChange={setOpen}
         settings={settings}
-        part={'dialog'}
         transcription={transcription}
       />
     </AmbientDialog>