@dxos/plugin-assistant 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/src/components/AssistantSettings/AssistantSettings.stories.tsx

@@ -6,7 +6,8 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
 
-import { translations } from '../../translations';
+import { translations } from '#translations';
+
 import { AssistantSettings } from './AssistantSettings';
 
 const meta = {
@@ -28,7 +29,7 @@ export const Default: Story = {
   args: {
     settings: {
       customPrompts: false,
-      llmProvider: 'edge',
+      modelProvider: 'edge',
     },
   },
 };

package/src/components/AssistantSettings/AssistantSettings.tsx

@@ -2,130 +2,41 @@
 // Copyright 2023 DXOS.org
 //
 
-import React from 'react';
+import React, { useMemo } from 'react';
 
-import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/ai';
+import { DEFAULT_EDGE_MODELS, DEFAULT_LMSTUDIO_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/ai';
 import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { Input, Select, useTranslation } from '@dxos/react-ui';
-import { Settings as SettingsForm } from '@dxos/react-ui-form';
+import { useTranslation } from '@dxos/react-ui';
+import { Settings as SettingsForm, createSelectField } from '@dxos/react-ui-form';
 
 import { meta } from '#meta';
-import { type Assistant, LLM_PROVIDERS } from '#types';
-
-// TODO(burdon): Factor out default Selector.
-const DEFAULT_VALUE = '__default';
-
-const LLM_PROVIDER_LABELS = {
-  edge: 'DXOS',
-  ollama: 'Ollama',
-  lmstudio: 'LM Studio',
-} as const;
+import { Assistant } from '#types';
 
 export type AssistantSettingsProps = AppSurface.SettingsArticleProps<Assistant.Settings>;
 
 export const AssistantSettings = ({ settings, onSettingsChange }: AssistantSettingsProps) => {
   const { t } = useTranslation(meta.id);
+  const fieldMap = useMemo(
+    () => ({
+      modelDefaults: {
+        edge: createSelectField({ options: DEFAULT_EDGE_MODELS }),
+        ollama: createSelectField({ options: DEFAULT_OLLAMA_MODELS }),
+        lmstudio: createSelectField({ options: DEFAULT_LMSTUDIO_MODELS }),
+      },
+    }),
+    [],
+  );
 
   return (
     <SettingsForm.Viewport>
       <SettingsForm.Section title={t('settings.title', { ns: meta.id })}>
-        <SettingsForm.Item
-          title={t('settings.custom-prompts.label')}
-          description={t('settings.custom-prompts.description')}
-        >
-          <Input.Switch
-            disabled={!onSettingsChange}
-            checked={!!settings.customPrompts}
-            onCheckedChange={(checked) => onSettingsChange?.((s) => ({ ...s, customPrompts: checked }))}
-          />
-        </SettingsForm.Item>
-
-        <SettingsForm.Item
-          title={t('settings.llm-provider.label')}
-          description={t('settings.llm-provider.description')}
-        >
-          <Select.Root
-            disabled={!onSettingsChange}
-            value={settings.llmProvider ?? 'edge'}
-            onValueChange={(value) => {
-              onSettingsChange?.((s) => ({
-                ...s,
-                llmProvider: value === DEFAULT_VALUE ? undefined : (value as any),
-              }));
-            }}
-          >
-            <Select.TriggerButton disabled={!onSettingsChange} placeholder={t('settings.llm-provider.label')} />
-            <Select.Portal>
-              <Select.Content>
-                <Select.Viewport>
-                  <Select.Option value={DEFAULT_VALUE}>{t('settings.default.label')}</Select.Option>
-                  {LLM_PROVIDERS.map((model) => (
-                    <Select.Option key={model} value={model}>
-                      {LLM_PROVIDER_LABELS[model]}
-                    </Select.Option>
-                  ))}
-                </Select.Viewport>
-                <Select.Arrow />
-              </Select.Content>
-            </Select.Portal>
-          </Select.Root>
-        </SettingsForm.Item>
-
-        <SettingsForm.Item
-          title={t('settings.edge-llm-model.label')}
-          description={t('settings.edge-llm-model.description')}
-        >
-          <Select.Root
-            disabled={!onSettingsChange}
-            value={settings.edgeModel ?? DEFAULT_VALUE}
-            onValueChange={(value) => {
-              onSettingsChange?.((s) => ({ ...s, edgeModel: value === DEFAULT_VALUE ? undefined : value }));
-            }}
-          >
-            <Select.TriggerButton disabled={!onSettingsChange} placeholder={t('settings.default-llm-model.label')} />
-            <Select.Portal>
-              <Select.Content>
-                <Select.Viewport>
-                  <Select.Option value={DEFAULT_VALUE}>{t('settings.default.label')}</Select.Option>
-                  {DEFAULT_EDGE_MODELS.map((model) => (
-                    <Select.Option key={model} value={model}>
-                      {model}
-                    </Select.Option>
-                  ))}
-                </Select.Viewport>
-                <Select.Arrow />
-              </Select.Content>
-            </Select.Portal>
-          </Select.Root>
-        </SettingsForm.Item>
-
-        <SettingsForm.Item
-          title={t('settings.ollama-llm-model.label')}
-          description={t('settings.ollama-llm-model.description')}
-        >
-          <Select.Root
-            disabled={!onSettingsChange}
-            value={settings.ollamaModel ?? DEFAULT_VALUE}
-            onValueChange={(value) => {
-              onSettingsChange?.((s) => ({ ...s, ollamaModel: value === DEFAULT_VALUE ? undefined : value }));
-            }}
-          >
-            <Select.TriggerButton disabled={!onSettingsChange} placeholder={t('settings.default-llm-model.label')} />
-            <Select.Portal>
-              <Select.Content>
-                <Select.Viewport>
-                  <Select.Option value={DEFAULT_VALUE}>{t('settings.default.label')}</Select.Option>
-                  {DEFAULT_OLLAMA_MODELS.map((model) => (
-                    <Select.Option key={model} value={model}>
-                      {model}
-                    </Select.Option>
-                  ))}
-                </Select.Viewport>
-                <Select.Arrow />
-              </Select.Content>
-            </Select.Portal>
-          </Select.Root>
-        </SettingsForm.Item>
+        <SettingsForm.FieldSet<Assistant.Settings>
+          readonly={!onSettingsChange}
+          schema={Assistant.Settings}
+          fieldMap={fieldMap}
+          values={settings}
+          onValuesChanged={(values) => onSettingsChange?.(() => values)}
+        />
       </SettingsForm.Section>
     </SettingsForm.Viewport>
   );

package/src/components/Chat/Chat.tsx

@@ -2,59 +2,34 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Extension, Prec } from '@codemirror/state';
-import { keymap } from '@codemirror/view';
 import { useAtomValue } from '@effect-atom/atom-react';
-import { createContext } from '@radix-ui/react-context';
 import * as Array from 'effect/Array';
 import * as Option from 'effect/Option';
 import React, { type PropsWithChildren, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { type Chat as ChatModule } from '@dxos/assistant-toolkit';
+import { Agent, Plan } from '@dxos/assistant-toolkit';
 import { Event } from '@dxos/async';
-import { type Database, Filter, Obj } from '@dxos/echo';
-import { useVoiceInput } from '@dxos/plugin-transcription';
-import { type Queue, useQuery } from '@dxos/react-client/echo';
+import { type Feed, Filter, Obj, Query } from '@dxos/echo';
+import { useQuery } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
-import { Input, type ThemedClassName, useDynamicRef, useTranslation } from '@dxos/react-ui';
-import { ChatEditor, type ChatEditorController, type ChatEditorProps } from '@dxos/react-ui-chat';
-import { type MarkdownStreamController } from '@dxos/react-ui-components';
+import { type MarkdownStreamController } from '@dxos/react-ui-markdown';
 import { Menu, MenuRootProps } from '@dxos/react-ui-menu';
 import { Message } from '@dxos/types';
-import { composable, composableProps, mx } from '@dxos/ui-theme';
-import { isTruthy, trim } from '@dxos/util';
+import { composable, composableProps } from '@dxos/ui-theme';
 
-import { useChatToolbarActions } from '#hooks';
-import { meta } from '#meta';
+import { useChatKeymapExtensions, useChatToolbarActions, useDebug } from '#hooks';
 
-import { type AiChatProcessor } from '../../processor';
 import {
-  ChatActions,
-  type ChatActionsProps,
-  ChatOptions,
-  type ChatPresetsProps,
-  ChatReferences,
-  ChatStatusIndicator,
+  ChatStatus,
+  ChatPrompt as NaturalChatPrompt,
+  type ChatPromptProps as NaturalChatPromptProps,
 } from '../ChatPrompt';
 import { ChatThread as NaturalChatThread, type ChatThreadProps as NaturalChatThreadProps } from '../ChatThread';
+import { TaskList } from '../TaskList';
+import { ChatContextProvider, type ChatContextValue, type ChatRequestTiming, useChatContext } from './context';
 import { type ChatEvent } from './events';
 
-//
-// Context
-// NOTE: The context should not be exported. It is only used internally.
-// Components outside of this Radix-style group shuld define their own APIs.
-//
-
-type ChatContextValue = {
-  debug?: boolean;
-  event: Event<ChatEvent>;
-  db?: Database.Database;
-  chat?: ChatModule.Chat;
-  messages: Message.Message[];
-  processor: AiChatProcessor;
-};
-
-export const [ChatContextProvider, useChatContext] = createContext<ChatContextValue>('Chat');
+export { useChatContext };
 
 //
 // Root
@@ -62,49 +37,31 @@ export const [ChatContextProvider, useChatContext] = createContext<ChatContextVa
 
 type ChatRootProps = PropsWithChildren<
   Pick<ChatContextValue, 'db' | 'chat' | 'processor'> & {
-    queue?: Queue;
+    feed?: Feed.Feed;
     onEvent?: (event: ChatEvent) => void;
   }
 >;
 
-const ChatRoot = ({ children, chat, queue, processor, onEvent, ...props }: ChatRootProps) => {
+const ChatRoot = ({ children, chat, feed, processor, onEvent, ...props }: ChatRootProps) => {
   const [debug, setDebug] = useState(false);
-  const pending = useAtomValue(processor.messages);
   const streaming = useAtomValue(processor.streaming);
+  const active = useAtomValue(processor.active);
+  const requestTiming = useRequestTiming({ active });
   const lastPrompt = useRef<string | undefined>(undefined);
+  const db = props.db ?? (chat && Obj.getDatabase(chat));
+
+  const feedMessages = useQuery(
+    db,
+    feed ? Query.select(Filter.type(Message.Message)).from(feed) : Query.select(Filter.nothing()),
+  );
+  const pendingMessages = useAtomValue(processor.messages);
+  const messages = useMemo(
+    () => Array.dedupeWith([...feedMessages, ...pendingMessages], ({ id: a }, { id: b }) => a === b),
+    [feedMessages, pendingMessages],
+  );
+
+  const dump = useDebug({ processor });
 
-  // Messages.
-  const storedMessages = useQuery(queue, Filter.type(Message.Message));
-  const messages = useMemo(() => {
-    return Array.dedupeWith([...storedMessages, ...pending], ({ id: a }, { id: b }) => a === b);
-  }, [storedMessages, pending]);
-
-  // Debug.
-  const dump = useCallback(async () => {
-    const objects = processor.context.getObjects();
-    const blueprints = processor.context.getBlueprints();
-    const system = await processor.getSystemPrompt();
-    const tools = await processor.getTools();
-
-    // eslint-disable-next-line no-console
-    // eslint-disable-next-line no-console
-    console.group('Chat', { objects, blueprints });
-    // eslint-disable-next-line no-console
-    console.log(trim`
-      System Prompt:
-      ${system}
-    `);
-    // eslint-disable-next-line no-console
-    console.log(trim`
-      Tools:
-      ${Object.values(tools)
-        .map((tool) => JSON.stringify(tool, null, 2))
-        .join('\n')}
-    `);
-    console.groupEnd();
-  }, [processor]);
-
-  // Events.
   const event = useMemo(() => new Event<ChatEvent>(), []);
   useEffect(() => {
     return event.on((ev) => {
@@ -152,8 +109,6 @@ const ChatRoot = ({ children, chat, queue, processor, onEvent, ...props }: ChatR
     });
   }, [event, dump, processor, streaming, onEvent]);
 
-  const db = props.db ?? (chat && Obj.getDatabase(chat));
-
   return (
     <ChatContextProvider
       debug={debug}
@@ -162,6 +117,7 @@ const ChatRoot = ({ children, chat, queue, processor, onEvent, ...props }: ChatR
       chat={chat}
       messages={messages}
       processor={processor}
+      requestTiming={requestTiming}
       {...props}
     >
       {children}
@@ -171,15 +127,53 @@ const ChatRoot = ({ children, chat, queue, processor, onEvent, ...props }: ChatR
 
 ChatRoot.displayName = 'Chat.Root';
 
+const useRequestTiming = ({ active }: { active: boolean }) => {
+  const [requestTiming, setRequestTiming] = useState<ChatRequestTiming | null>(null);
+  useEffect(() => {
+    if (active) {
+      setRequestTiming({ startedAt: Date.now(), endedAt: null });
+    } else {
+      setRequestTiming((prev) => (prev && prev.endedAt == null ? { ...prev, endedAt: Date.now() } : prev));
+    }
+  }, [active]);
+
+  return requestTiming;
+};
+
+//
+// Toolbar
+//
+
+const CHAT_TOOLBAR_NAME = 'Chat.Toolbar';
+
+type ChatToolbarProps = Pick<MenuRootProps, 'attendableId'> & {
+  companionTo?: Obj.Unknown;
+};
+
+const ChatToolbar = composable<HTMLDivElement, ChatToolbarProps>(
+  ({ attendableId, companionTo, ...props }, forwardedRef) => {
+    const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
+    const menuActions = useChatToolbarActions({ chat, companionTo });
+
+    return (
+      <Menu.Root {...menuActions} attendableId={attendableId}>
+        <Menu.Toolbar {...composableProps(props)} ref={forwardedRef} />
+      </Menu.Root>
+    );
+  },
+);
+
+ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
+
 //
-// Viewport
+// Content
 //
 
-const CHAT_VIEWPORT_NAME = 'Chat.Viewport';
+const CHAT_CONTENT_NAME = 'Chat.Content';
 
-type ChatViewportProps = {};
+type ChatContentProps = {};
 
-const ChatViewport = composable<HTMLDivElement, ChatViewportProps>(({ children, ...props }, forwardedRef) => {
+const ChatContent = composable<HTMLDivElement, ChatContentProps>(({ children, ...props }, forwardedRef) => {
   return (
     <div {...composableProps(props, { classNames: 'dx-expander flex flex-col' })} ref={forwardedRef}>
       {children}
@@ -187,7 +181,7 @@ const ChatViewport = composable<HTMLDivElement, ChatViewportProps>(({ children,
   );
 });
 
-ChatViewport.displayName = CHAT_VIEWPORT_NAME;
+ChatContent.displayName = CHAT_CONTENT_NAME;
 
 //
 // Thread
@@ -197,10 +191,12 @@ const CHAT_THREAD_NAME = 'Chat.Thread';
 
 type ChatThreadProps = Omit<NaturalChatThreadProps, 'identity' | 'messages' | 'tools'>;
 
-const ChatThread = (props: ChatThreadProps) => {
+const ChatThread = ({ viewType, debug: debugProp, ...props }: ChatThreadProps) => {
   const { debug, event, messages, processor } = useChatContext(CHAT_THREAD_NAME);
+  const debugView = viewType === 'debug';
   const identity = useIdentity();
   const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
+  const extensions = useChatKeymapExtensions({ event });
 
   const controllerRef = useRef<MarkdownStreamController | null>(null);
   useEffect(() => {
@@ -228,7 +224,7 @@ const ChatThread = (props: ChatThreadProps) => {
   );
 
   if (!identity) {
-    return null;
+    return <div className='dx-expander' />;
   }
 
   return (
@@ -237,7 +233,9 @@ const ChatThread = (props: ChatThreadProps) => {
       identity={identity}
       messages={messages}
       error={error}
-      debug={debug}
+      debug={debugProp ?? (debug || debugView)}
+      viewType={viewType}
+      extensions={extensions}
       onEvent={handleEvent}
       ref={controllerRef}
     />
@@ -252,212 +250,38 @@ ChatThread.displayName = CHAT_THREAD_NAME;
 
 const CHAT_PROMPT_NAME = 'Chat.Prompt';
 
-type ChatPromptProps = ThemedClassName<
-  {
-    outline?: boolean;
-    settings?: boolean;
-  } & Pick<ChatEditorProps, 'placeholder'> &
-    Omit<ChatPresetsProps, 'onChange'> & {
-      expandable?: boolean;
-      online?: boolean;
-      onOnlineChange?: (online: boolean) => void;
-      onPresetChange?: ChatPresetsProps['onChange'];
-    }
->;
-
-const ChatPrompt = ({
-  classNames,
-  outline,
-  settings = true,
-  placeholder,
-  expandable,
-  online,
-  presets,
-  preset,
-  onPresetChange,
-  onOnlineChange,
-}: ChatPromptProps) => {
-  const { t } = useTranslation(meta.id);
-  const { db, processor, event } = useChatContext(CHAT_PROMPT_NAME);
+type ChatPromptProps = Omit<NaturalChatPromptProps, 'chat' | 'db' | 'processor' | 'event'>;
 
-  const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
-  const streaming = useAtomValue(processor.streaming);
-  const active = useAtomValue(processor.active);
-  const activeRef = useDynamicRef(active);
-
-  const editorRef = useRef<ChatEditorController>(null);
-  const [recordingState, setRecordingState] = useState(false);
-  useEffect(() => {
-    return event.on((event) => {
-      switch (event.type) {
-        case 'update-prompt':
-          if (!editorRef.current?.getText()?.length) {
-            editorRef.current?.setText(event.text);
-            editorRef.current?.focus();
-          }
-          break;
-        case 'record-start':
-          setRecordingState(true);
-          break;
-        case 'record-stop':
-          setRecordingState(false);
-          break;
-      }
-    });
-  }, [event]);
-
-  // TODO(burdon): Configure capability in TranscriptionPlugin.
-  const { recording } = useVoiceInput({
-    active: recordingState,
-    onUpdate: (text) => {
-      editorRef.current?.setText(text);
-      editorRef.current?.focus();
-    },
-  });
-
-  const extensions = useMemo<Extension[]>(() => {
-    return [
-      Prec.highest(
-        keymap.of([
-          {
-            key: 'Mod-d',
-            preventDefault: true,
-            run: () => {
-              event.emit({ type: 'toggle-debug' });
-              return true;
-            },
-          },
-          {
-            key: 'Mod-ArrowUp',
-            preventDefault: true,
-            run: () => {
-              event.emit({ type: 'nav-previous' });
-              return true;
-            },
-            shift: () => {
-              event.emit({ type: 'thread-open' });
-              return true;
-            },
-          },
-          {
-            key: 'Mod-ArrowDown',
-            preventDefault: true,
-            run: () => {
-              event.emit({ type: 'nav-next' });
-              return true;
-            },
-            shift: () => {
-              event.emit({ type: 'thread-close' });
-              return true;
-            },
-          },
-        ]),
-      ),
-    ].filter(isTruthy);
-  }, [event, expandable]);
-
-  const handleSubmit = useCallback<NonNullable<ChatEditorProps['onSubmit']>>(
-    (text) => {
-      if (!activeRef.current) {
-        event.emit({ type: 'submit', text });
-        return true;
-      }
-    },
-    [event],
-  );
-
-  const handleEvent = useCallback<NonNullable<ChatActionsProps['onEvent']>>(
-    (ev) => {
-      event.emit(ev);
-    },
-    [event],
-  );
-
-  return (
-    <div
-      role='group'
-      className={mx(
-        'flex flex-col w-full dx-density-fine',
-        outline &&
-          'bg-group-surface border border-subdued-separator transition transition-border [&:has(.cm-content:focus)]:border-separator rounded-sm',
-        classNames,
-      )}
-    >
-      <div role='none' className='flex p-2 gap-2'>
-        <ChatStatusIndicator classNames='p-1' preset={preset} error={error} processing={streaming} />
-        <ChatEditor
-          ref={editorRef}
-          autoFocus
-          lineWrapping
-          classNames='col-span-2 pt-0.5'
-          placeholder={placeholder ?? t('prompt.placeholder')}
-          extensions={extensions}
-          onSubmit={handleSubmit}
-        />
-      </div>
-
-      {db && settings && (
-        <div role='none' className='flex items-center overflow-hidden'>
-          <ChatOptions
-            db={db}
-            blueprintRegistry={processor.blueprintRegistry}
-            context={processor.context}
-            preset={preset}
-            presets={presets}
-            onPresetChange={onPresetChange}
-          />
-
-          <div role='none' className='flex grow overflow-x-auto scrollbar-none'>
-            <ChatReferences db={db} context={processor.context} />
-          </div>
-
-          <ChatActions
-            classNames='col-span-2'
-            microphone={true}
-            recording={recording}
-            processing={streaming}
-            onEvent={handleEvent}
-          >
-            {/* TODO(burdon): Move offline switch into dialog. */}
-            {online !== undefined && (
-              <Input.Root>
-                <Input.Label srOnly>{t('online-switch.label')}</Input.Label>
-                <Input.Switch classNames='mx-2' checked={online} onCheckedChange={onOnlineChange} />
-              </Input.Root>
-            )}
-          </ChatActions>
-        </div>
-      )}
-    </div>
-  );
+const ChatPrompt = (props: ChatPromptProps) => {
+  const { chat, db, processor, event } = useChatContext(CHAT_PROMPT_NAME);
+  return <NaturalChatPrompt {...props} chat={chat} db={db} processor={processor} event={event} />;
 };
 
 ChatPrompt.displayName = CHAT_PROMPT_NAME;
 
 //
-// Toolbar
+// TaskList
 //
 
-const CHAT_TOOLBAR_NAME = 'Chat.Toolbar';
+const CHAT_TASK_LIST_NAME = 'Chat.TaskList';
 
-type ChatToolbarProps = Pick<MenuRootProps, 'attendableId'> & {
-  companionTo?: Obj.Unknown;
+type ChatTaskListProps = {
+  plan?: Plan.Plan;
 };
 
-const ChatToolbar = composable<HTMLDivElement, ChatToolbarProps>(
-  ({ attendableId, companionTo, ...props }, forwardedRef) => {
-    const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
-    const menuActions = useChatToolbarActions({ chat, companionTo });
+const ChatTaskList = composable<HTMLDivElement, ChatTaskListProps>(({ plan: planProp, ...props }, forwardedRef) => {
+  const { chat } = useChatContext(CHAT_TASK_LIST_NAME);
+  const parent = chat ? Obj.getParent(chat) : undefined;
+  const agent = parent && Obj.instanceOf(Agent.Agent, parent) ? parent : undefined;
+  const plan = planProp ?? agent?.plan.target;
+  if (!plan) {
+    return null;
+  }
 
-    return (
-      <Menu.Root {...menuActions} attendableId={attendableId}>
-        <Menu.Toolbar {...composableProps(props)} ref={forwardedRef} />
-      </Menu.Root>
-    );
-  },
-);
+  return <TaskList {...props} plan={plan} ref={forwardedRef} />;
+});
 
-ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
+ChatTaskList.displayName = CHAT_TASK_LIST_NAME;
 
 //
 // Chat
@@ -465,10 +289,12 @@ ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
 
 export const Chat = {
   Root: ChatRoot,
-  Viewport: ChatViewport,
-  Thread: ChatThread,
-  Prompt: ChatPrompt,
   Toolbar: ChatToolbar,
+  Content: ChatContent,
+  Prompt: ChatPrompt,
+  Status: ChatStatus,
+  Thread: ChatThread,
+  TaskList: ChatTaskList,
 };
 
-export type { ChatRootProps, ChatViewportProps, ChatThreadProps, ChatPromptProps, ChatToolbarProps, ChatEvent };
+export type { ChatRootProps, ChatToolbarProps, ChatContentProps, ChatPromptProps, ChatThreadProps, ChatEvent };