@dxos/plugin-assistant 0.8.4-main.28f8d3d → 0.8.4-main.2c6827d

package/src/components/ChatCompanion.tsx

@@ -0,0 +1,155 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Array from 'effect/Array';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { Capabilities, createIntent } from '@dxos/app-framework';
+import { useCapabilities, useIntentDispatcher } from '@dxos/app-framework/react';
+import { Blueprint } from '@dxos/blueprints';
+import { getSpace } from '@dxos/client/echo';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { SpaceAction } from '@dxos/plugin-space/types';
+import { useQuery } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { ChatContainer, type ChatEvent } from '../components';
+import { useBlueprintRegistry, useContextBinder } from '../hooks';
+import { Assistant, AssistantAction } from '../types';
+
+export type ChatCompanionProps = {
+  role?: string;
+  data: { subject: Assistant.Chat | 'assistant-chat'; companionTo: Obj.Any };
+};
+
+export const ChatCompanion = ({ role, data }: ChatCompanionProps) => {
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const blueprintRegistry = useBlueprintRegistry();
+  const companionTo = data.companionTo;
+
+  const space = getSpace(companionTo);
+  const [chat, setChat] = useState(data.subject === 'assistant-chat' ? undefined : data.subject);
+  useEffect(() => {
+    setChat(data.subject === 'assistant-chat' ? undefined : data.subject);
+  }, [data.subject]);
+
+  const chatQueue = space && chat ? space.queues.get(chat.queue.dxn) : undefined;
+  const binder = useContextBinder(chatQueue);
+
+  // Initialize companion chat if it doesn't exist, but don't add it to the space immediately.
+  useAsyncEffect(async () => {
+    if (!space || chat) {
+      return;
+    }
+
+    const { data } = await dispatch(createIntent(AssistantAction.CreateChat, { space }));
+    setChat(data?.object);
+  }, [chat, space]);
+
+  // Add chat to space when user submits the first message.
+  const handleEvent = useCallback(
+    async (event: ChatEvent) => {
+      const chatInSpace = !!getSpace(chat);
+      if (chatInSpace || !chat || !space) {
+        return;
+      }
+
+      if (event.type === 'submit') {
+        await dispatch(
+          createIntent(SpaceAction.AddObject, {
+            object: chat,
+            target: space,
+            hidden: true,
+          }),
+        );
+        await dispatch(
+          createIntent(SpaceAction.AddRelation, {
+            space,
+            schema: Assistant.CompanionTo,
+            source: chat,
+            target: companionTo,
+          }),
+        );
+        await dispatch(
+          createIntent(AssistantAction.SetCurrentChat, {
+            companionTo,
+            chat,
+          }),
+        );
+      }
+    },
+    [chat, space, companionTo, dispatch],
+  );
+
+  const metadata = useCapabilities(Capabilities.Metadata);
+  const blueprintKeys = useMemo(
+    () =>
+      Function.pipe(
+        metadata,
+        Array.findFirst(
+          (
+            capability,
+          ): capability is {
+            id: string;
+            metadata: { blueprints?: string[] };
+          } => capability.id === Obj.getTypename(companionTo),
+        ),
+        Option.flatMap((c) => Option.fromNullable(c.metadata.blueprints)),
+        Option.getOrElse(() => [] as string[]),
+      ),
+    [metadata, companionTo],
+  );
+  const existingBlueprints = useQuery(space, Filter.type(Blueprint.Blueprint));
+  const pluginBlueprints = useMemo(
+    () => existingBlueprints.filter((blueprint) => blueprintKeys.includes(blueprint.key)),
+    [existingBlueprints, blueprintKeys],
+  );
+
+  // Initialize related blueprints that are not already in the space.
+  useAsyncEffect(async () => {
+    if (!space) {
+      return;
+    }
+
+    // NOTE: This must be run instead of using the useQuery result to avoid duplicates.
+    const { objects: existingBlueprints } = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
+    for (const key of blueprintKeys) {
+      const existingBlueprint = existingBlueprints.find((blueprint) => blueprint.key === key);
+      if (existingBlueprint) {
+        continue;
+      }
+
+      const blueprint = blueprintRegistry.getByKey(key);
+      if (!blueprint) {
+        continue;
+      }
+
+      space.db.add(Obj.clone(blueprint));
+    }
+  }, [space, blueprintRegistry, blueprintKeys]);
+
+  useAsyncEffect(async () => {
+    if (!binder?.isOpen) {
+      return;
+    }
+
+    if (pluginBlueprints.length > 0) {
+      await binder.bind({
+        blueprints: pluginBlueprints.map((blueprint) => Ref.make(blueprint)),
+      });
+    }
+
+    if (Obj.instanceOf(Blueprint.Blueprint, companionTo)) {
+      await binder.bind({ blueprints: [Ref.make(companionTo)] });
+    } else {
+      await binder.bind({ objects: [Ref.make(companionTo)] });
+    }
+  }, [binder, companionTo, blueprintKeys]);
+
+  return <ChatContainer role={role} space={space} chat={chat} companionTo={companionTo} onEvent={handleEvent} />;
+};
+
+export default ChatCompanion;

package/src/components/ChatContainer.tsx

@@ -2,65 +2,57 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useEffect } from 'react';
+import React from 'react';
 
-import { Capabilities, useCapability } from '@dxos/app-framework';
-import { getSpace } from '@dxos/client/echo';
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/react';
+import { type Space, getSpace } from '@dxos/client/echo';
+import { type Obj } from '@dxos/echo';
 import { StackItem } from '@dxos/react-ui-stack';
-import { type MaybePromise } from '@dxos/util';
 
-import {
-  type AiChatProcessor,
-  useBlueprintRegistry,
-  useChatProcessor,
-  useChatServices,
-  useOnline,
-  usePresets,
-} from '../hooks';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
 import { meta } from '../meta';
 import { type Assistant } from '../types';
 
-import { Chat } from './Chat';
+import { Chat, type ChatRootProps } from './Chat';
 
 export type ChatContainerProps = {
-  chat: Assistant.Chat;
   role?: string;
-  onProcessorReady?: (processor: AiChatProcessor) => MaybePromise<void>;
-};
+  space?: Space;
+  chat?: Assistant.Chat;
+  companionTo?: Obj.Any;
+} & Pick<ChatRootProps, 'onEvent'>;
 
-export const ChatContainer = ({ chat, onProcessorReady }: ChatContainerProps) => {
-  const space = getSpace(chat);
+export const ChatContainer = ({ space: spaceProp, chat, companionTo, onEvent }: ChatContainerProps) => {
+  const space = spaceProp ?? getSpace(chat);
   const settings = useCapability(Capabilities.SettingsStore).getStore<Assistant.Settings>(meta.id)?.value;
-  const services = useChatServices({ space });
+  const services = useChatServices({ space, chat });
   const [online, setOnline] = useOnline();
   const { preset, ...chatProps } = usePresets(online);
   const blueprintRegistry = useBlueprintRegistry();
-  const processor = useChatProcessor({ space, chat, preset, services, blueprintRegistry, settings });
-
-  useEffect(() => {
-    if (processor && onProcessorReady) {
-      const timeout = setTimeout(() => onProcessorReady(processor));
-      return () => clearTimeout(timeout);
-    }
-  }, [processor, onProcessorReady]);
-
-  if (!chat || !processor) {
+  const processor = useChatProcessor({
+    space,
+    chat,
+    preset,
+    services,
+    blueprintRegistry,
+    settings,
+  });
+
+  if (!processor) {
     return null;
   }
 
   return (
-    <StackItem.Content classNames='container-max-width'>
-      <Chat.Root chat={chat} processor={processor}>
-        <Chat.Thread />
-        <div className='p-2'>
-          <Chat.Prompt
-            {...chatProps}
-            classNames='p-2 border border-transparent rounded-md'
-            preset={preset?.id}
-            online={online}
-            onChangeOnline={setOnline}
-          />
-        </div>
+    <StackItem.Content toolbar>
+      <Chat.Root space={space} chat={chat} processor={processor} onEvent={onEvent}>
+        <Chat.Toolbar companionTo={companionTo} />
+        <Chat.Viewport classNames='container-max-width'>
+          <Chat.Thread />
+          <div role='none' className='p-4'>
+            <Chat.Prompt {...chatProps} outline preset={preset?.id} online={online} onOnlineChange={setOnline} />
+          </div>
+        </Chat.Viewport>
       </Chat.Root>
     </StackItem.Content>
   );

package/src/components/ChatDialog.tsx

@@ -4,10 +4,11 @@
 
 import React, { useCallback, useState } from 'react';
 
-import { Capabilities, useCapability } from '@dxos/app-framework';
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/react';
 import { getSpace } from '@dxos/client/echo';
 import { useTranslation } from '@dxos/react-ui';
-import { ChatDialog as NativeChatDialog } from '@dxos/react-ui-chat';
+import { ChatDialog as NaturalChatDialog } from '@dxos/react-ui-chat';
 
 import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
 import { meta } from '../meta';
@@ -24,11 +25,17 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
 
   const space = getSpace(chat);
   const settings = useCapability(Capabilities.SettingsStore).getStore<Assistant.Settings>(meta.id)?.value;
-  const services = useChatServices({ space });
+  const services = useChatServices({ space, chat });
   const [online, setOnline] = useOnline();
   const { preset, ...chatProps } = usePresets(online);
   const blueprintRegistry = useBlueprintRegistry();
-  const processor = useChatProcessor({ space, chat, preset, services, blueprintRegistry, settings });
+  const processor = useChatProcessor({
+    chat,
+    preset,
+    services,
+    blueprintRegistry,
+    settings,
+  });
 
   // TODO(burdon): Refocus when open.
   const [open, setOpen] = useState(true);
@@ -52,15 +59,15 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
 
   return (
     <Chat.Root chat={chat} processor={processor} onEvent={handleEvent}>
-      <NativeChatDialog.Root open={open} expanded={expanded} onOpenChange={setOpen}>
-        <NativeChatDialog.Header title={t('assistant dialog title')} />
-        <NativeChatDialog.Content>
+      <NaturalChatDialog.Root open={open} expanded={expanded} onOpenChange={setOpen}>
+        <NaturalChatDialog.Header title={t('assistant dialog title')} />
+        <NaturalChatDialog.Content>
           <Chat.Thread />
-        </NativeChatDialog.Content>
-        <NativeChatDialog.Footer>
-          <Chat.Prompt {...chatProps} preset={preset?.id} online={online} onChangeOnline={setOnline} expandable />
-        </NativeChatDialog.Footer>
-      </NativeChatDialog.Root>
+        </NaturalChatDialog.Content>
+        <NaturalChatDialog.Footer classNames='p-1.5'>
+          <Chat.Prompt {...chatProps} preset={preset?.id} online={online} onOnlineChange={setOnline} expandable />
+        </NaturalChatDialog.Footer>
+      </NaturalChatDialog.Root>
     </Chat.Root>
   );
 };

package/src/components/ChatProgress/ChatProgress.tsx

@@ -0,0 +1,67 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { addEventListener } from '@dxos/async';
+import { Flex, ProgressBar, type ProgressBarProps, TextCrawl, useExecutionGraph } from '@dxos/react-ui-components';
+
+import { type Assistant } from '../../types';
+
+// TODO(burdon): Reset after each session.
+// TODO(burdon): Show after delay.
+// TODO(burdon): Test with errors.
+// TODO(burdon): Filter out empty trace messages.
+
+// {
+//   "id": "01K3TE3C2VAXETP500QKDHK3C4_block_3",
+//   "branch": "main",
+//   "parents": [],
+//   "icon": "ph--robot--regular",
+//   "message": "\n"
+// }
+
+export type ChatProgressProps = {
+  chat: Assistant.Chat;
+};
+
+export const ChatProgress = ({ chat }: ChatProgressProps) => {
+  const { commits } = useExecutionGraph(chat.traceQueue?.target, true);
+  const nodes = useMemo(() => commits.map((commit) => ({ id: commit.id, message: commit.message })), [commits]);
+  const lines = useMemo(() => commits.map((commit) => commit.message), [commits]);
+
+  const [index, setIndex] = useState<number | undefined>(undefined);
+  const handleSelect = useCallback<NonNullable<ProgressBarProps['onSelect']>>(({ index }) => {
+    setIndex((current) => {
+      return current === index ? undefined : index;
+    });
+  }, []);
+
+  const ref = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    if (!ref.current) {
+      return;
+    }
+
+    return addEventListener(ref.current, 'keydown', (event) => {
+      switch (event.key) {
+        case 'ArrowLeft': {
+          setIndex((current) => (current === undefined || current <= 0 ? 0 : current - 1));
+          break;
+        }
+        case 'ArrowRight': {
+          setIndex((current) => (current === undefined || current >= nodes.length ? nodes.length - 1 : current + 1));
+          break;
+        }
+      }
+    });
+  }, [nodes.length]);
+
+  return (
+    <Flex column tabIndex={0} ref={ref} classNames='outline-none'>
+      <ProgressBar nodes={nodes} index={index} onSelect={handleSelect} />
+      <TextCrawl classNames='pis-4 text-sm text-description' lines={lines} autoAdvance />
+    </Flex>
+  );
+};

package/src/components/{Timeline → ChatProgress}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './Timeline';
+export * from './ChatProgress';

package/src/components/ChatPrompt/ChatActions.tsx

@@ -26,40 +26,24 @@ export const ChatActions = ({ classNames, children, microphone, recording, proce
     <div className={mx('flex items-center mie-1', classNames)}>
       {children}
 
-      {(processing && (
-        <IconButton
-          disabled={!processing}
-          classNames='px-1.5'
-          variant='ghost'
-          size={5}
-          icon='ph--x--regular'
-          iconOnly
-          label={t('button cancel processing')}
-          onClick={() => onEvent?.({ type: 'cancel' })}
-        />
-      )) || (
-        <IconButton
-          disabled
-          classNames='px-1.5'
-          variant='ghost'
-          size={5}
-          icon='ph--arrow-down--regular'
-          iconOnly
-          label={t('button scroll down')}
-          onClick={() => onEvent?.({ type: 'scroll-to-bottom' })}
-        />
-      )}
+      <IconButton
+        disabled={!processing}
+        variant='ghost'
+        icon='ph--x--regular'
+        iconOnly
+        label={t('cancel processing button')}
+        onClick={() => onEvent?.({ type: 'cancel' })}
+      />
 
       {microphone && (
         <IconButton
           disabled={!processing}
-          classNames={mx('px-1.5', recording && 'bg-primary-500')}
+          classNames={mx(recording && 'bg-primary-500')}
           variant='ghost'
-          size={5}
           icon='ph--microphone--regular'
           iconOnly
           noTooltip
-          label={t('button microphone')}
+          label={t('microphone button')}
           onMouseDown={() => onEvent?.({ type: 'record-start' })}
           onMouseUp={() => onEvent?.({ type: 'record-stop' })}
           onTouchStart={() => onEvent?.({ type: 'record-start' })}