@dxos/plugin-assistant 0.8.4-main.bc674ce → 0.8.4-main.c351d160a8

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -4,39 +4,33 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { getObjectPathFromObject, LayoutOperation } from '@dxos/app-toolkit';
 import { AiContextBinder, AiConversation } from '@dxos/assistant';
-import { Agent } from '@dxos/assistant-toolkit';
+import { AgentFunctions, Chat, ProjectWizardBlueprint } from '@dxos/assistant-toolkit';
+import { DatabaseBlueprint } from '@dxos/assistant-toolkit';
 import { Blueprint, Prompt } from '@dxos/blueprints';
 import { type Queue } from '@dxos/client/echo';
-import { Filter, Obj, Ref, Type } from '@dxos/echo';
+import { Filter, Obj, Ref } from '@dxos/echo';
 import { TracingService, serializeFunction } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { Operation, OperationResolver } from '@dxos/operation';
 import { AutomationCapabilities } from '@dxos/plugin-automation';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { Collection } from '@dxos/schema';
 import { type Message } from '@dxos/types';
 
+import { AssistantBlueprint } from '../../blueprints';
 import { type AiChatServices, updateName } from '../../processor';
-import { Assistant, AssistantCapabilities, AssistantOperation } from '../../types';
-import { AssistantBlueprint, createBlueprint } from '../blueprint-definition/blueprint-definition';
+import { AssistantCapabilities, AssistantOperation } from '../../types';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    return Capability.contributes(Common.Capability.OperationResolver, [
+    return Capability.contributes(Capabilities.OperationResolver, [
       OperationResolver.make({
         operation: AssistantOperation.OnCreateSpace,
-        handler: Effect.fnUntraced(function* ({ space, rootCollection }) {
-          const chatCollection = Collection.makeManaged({ key: Assistant.Chat.typename });
-          const blueprintCollection = Collection.makeManaged({ key: Blueprint.Blueprint.typename });
-          const promptCollection = Collection.makeManaged({ key: Type.getTypename(Prompt.Prompt) });
-          Obj.change(rootCollection, (c) => {
-            c.objects.push(Ref.make(chatCollection), Ref.make(blueprintCollection), Ref.make(promptCollection));
-          });
-
+        handler: Effect.fnUntraced(function* ({ space }) {
           // TODO(wittjosiah): Remove once function registry is avaiable.
-          space.db.add(serializeFunction(Agent.prompt));
+          space.db.add(serializeFunction(AgentFunctions.Prompt));
 
           // Create default chat.
           const { object: chat } = yield* Operation.invoke(AssistantOperation.CreateChat, { db: space.db });
@@ -45,26 +39,46 @@ export default Capability.makeModule(
       }),
       OperationResolver.make({
         operation: AssistantOperation.CreateChat,
-        handler: Effect.fnUntraced(function* ({ db, name }) {
-          const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+        handler: Effect.fnUntraced(function* ({ db, name, addToSpace = true }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
           const client = yield* Capability.get(ClientCapabilities.Client);
           const space = client.spaces.get(db.spaceId);
           invariant(space, 'Space not found');
           const queue = space.queues.create();
-          const chat = Assistant.make({ name, queue: Ref.fromDXN(queue.dxn) });
-          space.db.add(chat);
+          const chat = Chat.make({ name, queue: db.makeRef<any>(queue.dxn) });
+          if (addToSpace) {
+            space.db.add(chat);
+          }
 
           // TODO(wittjosiah): This should be a space-level setting.
           // TODO(burdon): Clone when activated. Copy-on-write for template.
           const blueprints = yield* Effect.promise(() => db.query(Filter.type(Blueprint.Blueprint)).run());
-          let defaultBlueprint = blueprints.find((blueprint) => blueprint.key === AssistantBlueprint.Key);
-          if (!defaultBlueprint) {
-            defaultBlueprint = db.add(createBlueprint());
+          let defaultAssistantBlueprint = blueprints.find((blueprint) => blueprint.key === AssistantBlueprint.key);
+          if (!defaultAssistantBlueprint) {
+            defaultAssistantBlueprint = db.add(AssistantBlueprint.make());
+          }
+          let defaultDatabaseBlueprint = blueprints.find((blueprint) => blueprint.key === DatabaseBlueprint.key);
+          if (!defaultDatabaseBlueprint) {
+            defaultDatabaseBlueprint = db.add(DatabaseBlueprint.make());
+          }
+          let defaultProjectWizardBlueprint = blueprints.find(
+            (blueprint) => blueprint.key === ProjectWizardBlueprint.key,
+          );
+          if (!defaultProjectWizardBlueprint) {
+            defaultProjectWizardBlueprint = db.add(ProjectWizardBlueprint.make());
           }
 
           const binder = new AiContextBinder({ queue, registry });
           yield* Effect.promise(() =>
-            binder.use((b: AiContextBinder) => b.bind({ blueprints: [Ref.make(defaultBlueprint!)] })),
+            binder.use((b: AiContextBinder) =>
+              b.bind({
+                blueprints: [
+                  Ref.make(defaultAssistantBlueprint!),
+                  Ref.make(defaultDatabaseBlueprint!),
+                  Ref.make(defaultProjectWizardBlueprint!),
+                ],
+              }),
+            ),
           );
 
           return { object: chat };
@@ -73,7 +87,7 @@ export default Capability.makeModule(
       OperationResolver.make({
         operation: AssistantOperation.UpdateChatName,
         handler: Effect.fnUntraced(function* ({ chat }) {
-          const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
           const db = Obj.getDatabase(chat);
           const queue = chat.queue.target as Queue<Message.Message>;
           if (!db || !queue) {
@@ -99,12 +113,25 @@ export default Capability.makeModule(
         handler: Effect.fnUntraced(function* ({ companionTo, chat }) {
           const companionToId = Obj.getDXN(companionTo).toString();
           const chatId = chat && Obj.getDXN(chat).toString();
-          yield* Common.Capability.updateAtomValue(AssistantCapabilities.State, (current) => ({
+          yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
             ...current,
             currentChat: { ...current.currentChat, [companionToId]: chatId },
           }));
         }),
       }),
+      OperationResolver.make({
+        operation: AssistantOperation.RunPromptInNewChat,
+        handler: Effect.fnUntraced(function* ({ db, prompt }) {
+          const { object: chat } = yield* Operation.invoke(AssistantOperation.CreateChat, { db });
+          const chatPath = getObjectPathFromObject(chat);
+          yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
+            ...current,
+            pendingPrompts: { ...current.pendingPrompts, [chatPath]: prompt },
+          }));
+          yield* Operation.invoke(LayoutOperation.Open, { subject: [chatPath] });
+          return { object: chat };
+        }),
+      }),
     ]);
   }),
 );

package/src/capabilities/react-surface/react-surface.tsx

@@ -5,14 +5,16 @@
 import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { useSettingsState } from '@dxos/app-framework/react';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useSettingsState } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Chat, Project } from '@dxos/assistant-toolkit';
 import { Blueprint, Prompt } from '@dxos/blueprints';
 import { getSpace } from '@dxos/client/echo';
 import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
 import { Obj } from '@dxos/echo';
-import { Layout } from '@dxos/react-ui-mosaic';
+import { Panel } from '@dxos/react-ui';
 
 import {
   AssistantSettings,
@@ -20,42 +22,65 @@ import {
   ChatCompanion,
   ChatContainer,
   ChatDialog,
+  ProjectArticle,
+  ProjectSettings,
   PromptArticle,
-} from '../../components';
+  TracePanel,
+  TriggerStatus,
+} from '../../containers';
 import { ASSISTANT_DIALOG, meta } from '../../meta';
-import { Assistant } from '../../types';
+import { type Assistant } from '../../types';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
-    Capability.contributes(Common.Capability.ReactSurface, [
-      Common.createSurface({
-        id: `${meta.id}/plugin-settings`,
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}.plugin-settings`,
         role: 'article',
-        filter: (data): data is { subject: Common.Capability.Settings } =>
-          Common.Capability.isSettings(data.subject) && data.subject.prefix === meta.id,
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
         component: ({ data: { subject } }) => {
           const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
           return <AssistantSettings settings={settings} onSettingsChange={updateSettings} />;
         },
       }),
-      Common.createSurface({
-        id: `${meta.id}/chat`,
+      Surface.create({
+        id: `${meta.id}.chat`,
         role: 'article',
-        filter: (data): data is { subject: Assistant.Chat; variant: undefined } =>
-          Obj.instanceOf(Assistant.Chat, data.subject) && data.variant !== 'assistant-chat',
-        component: ({ data, role, ref }) => <ChatContainer role={role} subject={data.subject} ref={ref} />,
+        filter: (data): data is { attendableId: string; subject: Chat.Chat; variant: undefined } =>
+          typeof data.attendableId === 'string' &&
+          Obj.instanceOf(Chat.Chat, data.subject) &&
+          data.variant !== 'assistant-chat',
+        component: ({ data, role, ref }) => (
+          <ChatContainer role={role} subject={data.subject} attendableId={data.attendableId} ref={ref} />
+        ),
+      }),
+      Surface.create({
+        id: `${meta.id}.project`,
+        role: 'article',
+        filter: (data): data is { subject: Project.Project } => Obj.instanceOf(Project.Project, data.subject),
+        component: ({ data, role }) => <ProjectArticle role={role} subject={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.project.companion.settings`,
+        role: 'object-settings',
+        filter: (data): data is { subject: Project.Project } => Obj.instanceOf(Project.Project, data.subject),
+        component: ({ data }) => <ProjectSettings subject={data.subject} />,
       }),
       // TODO(wittjosiah): This is flashing when chat changes.
-      Common.createSurface({
-        id: `${meta.id}/companion-chat`,
+      Surface.create({
+        id: `${meta.id}.companion-chat`,
         role: 'article',
-        filter: (data): data is { companionTo: Obj.Unknown; subject: Assistant.Chat | 'assistant-chat' } =>
+        filter: (
+          data,
+        ): data is { attendableId: string; companionTo: Obj.Unknown; subject: Chat.Chat | 'assistant-chat' } =>
+          typeof data.attendableId === 'string' &&
           Obj.isObject(data.companionTo) &&
-          (Obj.instanceOf(Assistant.Chat, data.subject) || data.subject === 'assistant-chat'),
+          (Obj.instanceOf(Chat.Chat, data.subject) || data.subject === 'assistant-chat'),
         component: ({ data, role, ref }) => <ChatCompanion role={role} data={data} ref={ref} />,
       }),
-      Common.createSurface({
-        id: `${meta.id}/companion-invocations`,
+      Surface.create({
+        id: `${meta.id}.companion-invocations`,
         role: 'article',
         filter: (data): data is { companionTo: Sequence } =>
           (Obj.instanceOf(Sequence, data.companionTo) || Obj.instanceOf(Prompt.Prompt, data.companionTo)) &&
@@ -66,30 +91,43 @@ export default Capability.makeModule(() =>
           // TODO(wittjosiah): Support invocation filtering for prompts.
           const target = Obj.instanceOf(Prompt.Prompt, data.companionTo) ? undefined : data.companionTo;
           return (
-            <Layout.Main role={role}>
-              <InvocationTraceContainer db={space?.db} queueDxn={queueDxn} target={target} detailAxis='block' />
-            </Layout.Main>
+            <Panel.Root role={role} className='dx-document'>
+              <Panel.Content asChild>
+                <InvocationTraceContainer db={space?.db} queueDxn={queueDxn} target={target} detailAxis='block' />
+              </Panel.Content>
+            </Panel.Root>
           );
         },
       }),
-      Common.createSurface({
-        id: `${meta.id}/blueprint`,
+      Surface.create({
+        id: `${meta.id}.blueprint`,
         role: 'article',
         filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
         component: ({ data }) => <BlueprintArticle subject={data.subject} />,
       }),
-      Common.createSurface({
-        id: `${meta.id}/prompt`,
+      Surface.create({
+        id: `${meta.id}.prompt`,
         role: 'article',
         filter: (data): data is { subject: Prompt.Prompt } => Obj.instanceOf(Prompt.Prompt, data.subject),
         component: ({ data }) => <PromptArticle subject={data.subject} />,
       }),
-      Common.createSurface({
+      Surface.create({
         id: ASSISTANT_DIALOG,
         role: 'dialog',
-        filter: (data): data is { props: { chat: Assistant.Chat } } => data.component === ASSISTANT_DIALOG,
+        filter: (data): data is { props: { chat: Chat.Chat } } => data.component === ASSISTANT_DIALOG,
         component: ({ data }) => <ChatDialog {...data.props} />,
       }),
+      Surface.create({
+        id: `${meta.id}.trace`,
+        role: 'deck-companion--trace',
+        filter: (data): data is { subject: 'trace' } => data.subject === 'trace',
+        component: () => <TracePanel />,
+      }),
+      Surface.create({
+        id: `${meta.id}.status`,
+        role: 'status',
+        component: () => <TriggerStatus />,
+      }),
     ]),
   ),
 );

package/src/capabilities/settings/settings.ts

@@ -4,7 +4,8 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { createKvsStore } from '@dxos/effect';
 
 import { meta } from '../../meta';
@@ -20,7 +21,7 @@ export default Capability.makeModule(() =>
 
     return [
       Capability.contributes(AssistantCapabilities.Settings, settingsAtom),
-      Capability.contributes(Common.Capability.Settings, {
+      Capability.contributes(AppCapabilities.Settings, {
         prefix: meta.id,
         schema: Assistant.Settings,
         atom: settingsAtom,

package/src/capabilities/state/state.ts

@@ -19,6 +19,7 @@ export default Capability.makeModule(() =>
       schema: AssistantCapabilities.StateSchema,
       defaultValue: () => ({
         currentChat: {},
+        pendingPrompts: {},
       }),
     });
 

package/src/capabilities/toolkit/toolkit.ts

@@ -5,22 +5,11 @@
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { GenericToolkit } from '@dxos/assistant';
-import { AssistantToolkit, SystemToolkit, WebSearchToolkit } from '@dxos/assistant-toolkit';
+import { GenericToolkit } from '@dxos/ai';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { WebSearchToolkit } from '@dxos/assistant-toolkit';
 
 export default Capability.makeModule(() =>
-  Effect.succeed([
-    Capability.contributes(
-      Common.Capability.Toolkit,
-      GenericToolkit.make(AssistantToolkit.AssistantToolkit, AssistantToolkit.layer()),
-    ),
-
-    // TODO(burdon): How to manage dependencies across blueprints.
-    Capability.contributes(
-      Common.Capability.Toolkit,
-      GenericToolkit.make(SystemToolkit.SystemToolkit, SystemToolkit.layer()),
-    ),
-    Capability.contributes(Common.Capability.Toolkit, GenericToolkit.make(WebSearchToolkit, Layer.empty)),
-  ]),
+  Effect.succeed([Capability.contributes(AppCapabilities.Toolkit, GenericToolkit.make(WebSearchToolkit, Layer.empty))]),
 );

package/src/components/Chat/Chat.tsx

@@ -8,17 +8,26 @@ 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 React, {
+  type ComponentPropsWithoutRef,
+  type PropsWithChildren,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+import { type Chat as ChatModule } from '@dxos/assistant-toolkit';
 import { Event } from '@dxos/async';
-import { type Database, Obj } from '@dxos/echo';
+import { type Database, Filter, Obj } from '@dxos/echo';
 import { useVoiceInput } from '@dxos/plugin-transcription';
-import { useQueue } from '@dxos/react-client/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 { MenuProvider, ToolbarMenu } from '@dxos/react-ui-menu';
+import { Menu } from '@dxos/react-ui-menu';
 import { Message } from '@dxos/types';
 import { mx } from '@dxos/ui-theme';
 import { isTruthy } from '@dxos/util';
@@ -26,7 +35,6 @@ import { isTruthy } from '@dxos/util';
 import { useChatToolbarActions } from '../../hooks';
 import { meta } from '../../meta';
 import { type AiChatProcessor } from '../../processor';
-import { type Assistant } from '../../types';
 import {
   ChatActions,
   type ChatActionsProps,
@@ -49,7 +57,7 @@ type ChatContextValue = {
   debug?: boolean;
   event: Event<ChatEvent>;
   db?: Database.Database;
-  chat?: Assistant.Chat;
+  chat?: ChatModule.Chat;
   messages: Message.Message[];
   processor: AiChatProcessor;
 };
@@ -73,11 +81,10 @@ const ChatRoot = ({ children, chat, processor, onEvent, ...props }: ChatRootProp
   const lastPrompt = useRef<string | undefined>(undefined);
 
   // Messages.
-  const queue = useQueue<Message.Message>(chat?.queue.dxn);
+  const storedMessages = useQuery(chat?.queue?.target, Filter.type(Message.Message));
   const messages = useMemo(() => {
-    const queueMessages = queue?.objects?.filter(Obj.instanceOf(Message.Message)) ?? [];
-    return Array.dedupeWith([...queueMessages, ...pending], ({ id: a }, { id: b }) => a === b);
-  }, [queue?.objects, pending]);
+    return Array.dedupeWith([...storedMessages, ...pending], ({ id: a }, { id: b }) => a === b);
+  }, [storedMessages, pending]);
 
   // Events.
   const event = useMemo(() => new Event<ChatEvent>(), []);
@@ -85,7 +92,26 @@ const ChatRoot = ({ children, chat, processor, onEvent, ...props }: ChatRootProp
     return event.on((ev) => {
       switch (ev.type) {
         case 'toggle-debug': {
-          setDebug((current) => !current);
+          setDebug((debug) => !debug);
+
+          // Dump state to console.
+          queueMicrotask(async () => {
+            const objects = processor.context.getObjects();
+            const blueprints = processor.context.getBlueprints();
+            const tools = await processor.getTools();
+            const system = await processor.getSystemPrompt();
+            // eslint-disable-next-line no-console
+            console.log('Chat processor state:', { objects, blueprints });
+            // eslint-disable-next-line no-console
+            console.log(`
+              ==== System Prompt ====
+              ${system}
+              ==== Tools ====
+              ${Object.values(tools)
+                .map((tool) => JSON.stringify(tool, null, 2))
+                .join('\n')}
+            `);
+          });
           break;
         }
 
@@ -143,24 +169,30 @@ ChatRoot.displayName = 'Chat.Root';
 // Viewport
 //
 
-type ChatViewportProps = ThemedClassName<PropsWithChildren>;
+const CHAT_VIEWPORT_NAME = 'Chat.Viewport';
+
+type ChatViewportProps = ThemedClassName<PropsWithChildren<ComponentPropsWithoutRef<'div'>>>;
 
-const ChatViewport = ({ classNames, children }: ChatViewportProps) => {
+const ChatViewport = ({ classNames, children, ...props }: ChatViewportProps) => {
   return (
-    <div role='none' className={mx('flex flex-col bs-full is-full', classNames)}>
+    <div role='none' {...props} className={mx('flex flex-col h-full w-full', classNames)}>
       {children}
     </div>
   );
 };
 
+ChatViewport.displayName = CHAT_VIEWPORT_NAME;
+
 //
 // Thread
 //
 
+const CHAT_THREAD_NAME = 'Chat.Thread';
+
 type ChatThreadProps = Omit<NaturalChatThreadProps, 'identity' | 'messages' | 'tools'>;
 
 const ChatThread = (props: ChatThreadProps) => {
-  const { debug, event, messages, processor } = useChatContext(ChatThread.displayName);
+  const { debug, event, messages, processor } = useChatContext(CHAT_THREAD_NAME);
   const identity = useIdentity();
   const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
 
@@ -206,12 +238,14 @@ const ChatThread = (props: ChatThreadProps) => {
   );
 };
 
-ChatThread.displayName = 'Chat.Thread';
+ChatThread.displayName = CHAT_THREAD_NAME;
 
 //
 // Prompt
 //
 
+const CHAT_PROMPT_NAME = 'Chat.Prompt';
+
 type ChatPromptProps = ThemedClassName<
   {
     outline?: boolean;
@@ -238,7 +272,7 @@ const ChatPrompt = ({
   onOnlineChange,
 }: ChatPromptProps) => {
   const { t } = useTranslation(meta.id);
-  const { db, processor, event } = useChatContext(ChatPrompt.displayName);
+  const { db, processor, event } = useChatContext(CHAT_PROMPT_NAME);
 
   const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
   const streaming = useAtomValue(processor.streaming);
@@ -337,9 +371,9 @@ const ChatPrompt = ({
     <div
       role='group'
       className={mx(
-        'flex flex-col is-full density-fine',
+        'flex flex-col w-full dx-density-fine',
         outline &&
-          'bg-groupSurface border border-subduedSeparator transition transition-border [&:has(.cm-content:focus)]:border-separator rounded',
+          'bg-group-surface border border-subdued-separator transition transition-border [&:has(.cm-content:focus)]:border-separator rounded-sm',
         classNames,
       )}
     >
@@ -349,7 +383,7 @@ const ChatPrompt = ({
           ref={editorRef}
           autoFocus
           lineWrapping
-          classNames='col-span-2 pbs-0.5'
+          classNames='col-span-2 pt-0.5'
           placeholder={placeholder ?? t('prompt placeholder')}
           extensions={extensions}
           onSubmit={handleSubmit}
@@ -382,7 +416,7 @@ const ChatPrompt = ({
             {online !== undefined && (
               <Input.Root>
                 <Input.Label srOnly>{t('online switch label')}</Input.Label>
-                <Input.Switch classNames='mli-2' checked={online} onCheckedChange={onOnlineChange} />
+                <Input.Switch classNames='mx-2' checked={online} onCheckedChange={onOnlineChange} />
               </Input.Root>
             )}
           </ChatActions>
@@ -392,29 +426,28 @@ const ChatPrompt = ({
   );
 };
 
-ChatPrompt.displayName = 'Chat.Prompt';
+ChatPrompt.displayName = CHAT_PROMPT_NAME;
 
 //
 // Toolbar
 //
 
-type ChatToolbarProps = ThemedClassName<{ companionTo?: Obj.Unknown }>;
+const CHAT_TOOLBAR_NAME = 'Chat.Toolbar';
+
+type ChatToolbarProps = { companionTo?: Obj.Unknown } & ComponentPropsWithoutRef<typeof Menu.Root>;
 
-const ChatToolbar = ({ classNames, companionTo }: ChatToolbarProps) => {
-  const { chat } = useChatContext(ChatToolbar.displayName);
+const ChatToolbar = ({ companionTo, ...props }: ChatToolbarProps) => {
+  const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
   const menu = useChatToolbarActions({ chat, companionTo });
 
   return (
-    <MenuProvider
-      {...menu}
-      attendableId={companionTo ? Obj.getDXN(companionTo).toString() : chat ? Obj.getDXN(chat).toString() : ''}
-    >
-      <ToolbarMenu classNames={classNames} textBlockWidth />
-    </MenuProvider>
+    <Menu.Root {...props} {...menu}>
+      <Menu.Toolbar />
+    </Menu.Root>
   );
 };
 
-ChatToolbar.displayName = 'Chat.Toolbar';
+ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
 
 //
 // Chat

package/src/components/ChatProgress/ChatProgress.tsx

@@ -4,13 +4,12 @@
 
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
+import { type Chat } from '@dxos/assistant-toolkit';
 import { addEventListener } from '@dxos/async';
 import { ProgressBar, type ProgressBarProps, TextCrawl, useExecutionGraph } from '@dxos/react-ui-components';
 
-import { type Assistant } from '../../types';
-
 export type ChatProgressProps = {
-  chat: Assistant.Chat;
+  chat: Chat.Chat;
 };
 
 export const ChatProgress = ({ chat }: ChatProgressProps) => {
@@ -46,9 +45,9 @@ export const ChatProgress = ({ chat }: ChatProgressProps) => {
   }, [nodes.length]);
 
   return (
-    <div role='none' tabIndex={0} ref={ref} className='flex flex-col outline-none'>
+    <div role='none' tabIndex={0} ref={ref} className='flex flex-col outline-hidden'>
       <ProgressBar nodes={nodes} index={index} onSelect={handleSelect} />
-      <TextCrawl classNames='pis-4 text-sm text-description' lines={lines} autoAdvance />
+      <TextCrawl classNames='ps-4 text-sm text-description' lines={lines} autoAdvance />
     </div>
   );
 };

package/src/components/ChatPrompt/ChatActions.tsx

@@ -23,7 +23,7 @@ export const ChatActions = ({ classNames, children, microphone, recording, proce
   const { t } = useTranslation(meta.id);
 
   return (
-    <div className={mx('flex items-center mie-1', classNames)}>
+    <div className={mx('flex items-center me-1', classNames)}>
       {children}
 
       <IconButton
@@ -50,6 +50,14 @@ export const ChatActions = ({ classNames, children, microphone, recording, proce
           onTouchEnd={() => onEvent?.({ type: 'record-stop' })}
         />
       )}
+
+      <IconButton
+        variant='ghost'
+        icon='ph--wrench--regular'
+        iconOnly
+        label={t('debug button')}
+        onClick={() => onEvent?.({ type: 'toggle-debug' })}
+      />
     </div>
   );
 };