@dxos/plugin-assistant 0.8.3-staging.0fa589b → 0.8.4-main.1da679c

package/src/components/ChatPrompt/ChatReferences.tsx

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type AiContextBinder } from '@dxos/assistant';
+import { Obj } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+import { IconButton, type Label, type ThemedClassName, toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { mx } from '@dxos/react-ui-theme';
+
+import { useContextObjects } from '../../hooks';
+import { meta } from '../../meta';
+
+export type ChatReferencesProps = ThemedClassName<{
+  context: AiContextBinder;
+  space: Space;
+}>;
+
+export const ChatReferences = ({ classNames, context, space }: ChatReferencesProps) => {
+  const { t } = useTranslation(meta.id);
+  const { objects, onUpdateObject } = useContextObjects({ space, context });
+
+  return (
+    <ul className={mx('flex flex-wrap', classNames)}>
+      {objects.map((obj) => {
+        const dxn = Obj.getDXN(obj);
+        const typename = Obj.getTypename(obj);
+        const label: Label = Obj.getLabel(obj) ?? (typename ? ['object name placeholder', { ns: typename }] : obj.id);
+        return (
+          <li key={dxn.toString()} className='dx-tag plb-0 pis-2 flex items-center' data-hue='neutral'>
+            {toLocalizedString(label, t)}
+            <IconButton
+              iconOnly
+              variant='ghost'
+              label={t('remove object in context label')}
+              classNames='p-0 hover:bg-transparent'
+              size={3}
+              icon='ph--x--bold'
+              onClick={() => onUpdateObject?.(dxn, false)}
+            />
+          </li>
+        );
+      })}
+    </ul>
+  );
+};

package/src/components/ChatPrompt/ChatStatusIndicator.tsx

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useEffect, useState } from 'react';
+
+import { type ThemedClassName, Tooltip, useTimeout } from '@dxos/react-ui';
+import { Spinner, type SpinnerProps } from '@dxos/react-ui-sfx';
+import { mx } from '@dxos/react-ui-theme';
+
+const period = 3_000;
+
+export type ChatStatusIndicatorProps = ThemedClassName<
+  {
+    preset?: string;
+    processing?: boolean;
+    error?: Error;
+  } & Pick<SpinnerProps, 'size' | 'onClick'>
+>;
+
+export const ChatStatusIndicator = ({ classNames, preset, processing, error, ...props }: ChatStatusIndicatorProps) => {
+  const [init, setInit] = useState(false);
+  useEffect(() => setInit(false), [preset]);
+  useTimeout(
+    async () => {
+      setInit(true);
+    },
+    period / 2,
+    [preset],
+  );
+
+  return (
+    <div role='none' className={mx('relative flex', classNames)}>
+      <Spinner duration={period} state={!init ? 'flash' : error ? 'error' : processing ? 'spin' : 'pulse'} {...props} />
+      {error && (
+        <Tooltip.Trigger asChild content={error.message}>
+          <div className='absolute inset-0' />
+        </Tooltip.Trigger>
+      )}
+    </div>
+  );
+};

package/src/components/ChatPrompt/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './ChatActions';
+export * from './ChatOptions';
+export * from './ChatPresets';
+export * from './ChatReferences';
+export * from './ChatStatusIndicator';

package/src/components/ChatThread/ChatThread.stories.tsx

@@ -0,0 +1,130 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import { Effect, Fiber, Layer } from 'effect';
+import React, { useEffect, useMemo, useState } from 'react';
+
+import { ContextQueueService, DatabaseService } from '@dxos/functions';
+import { faker } from '@dxos/random';
+import { useQueue, useSpace } from '@dxos/react-client/echo';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { Popover } from '@dxos/react-ui';
+import { PreviewPopoverProvider, usePreviewPopover } from '@dxos/react-ui-editor/testing';
+import { Card } from '@dxos/react-ui-stack';
+import { DataType } from '@dxos/schema';
+import { withLayout, withTheme } from '@dxos/storybook-utils';
+
+import { createMessageGenerator } from '../../testing';
+import { translations } from '../../translations';
+
+import { ChatThread, type ChatThreadController, type ChatThreadProps } from './ChatThread';
+
+faker.seed(1);
+
+type MessageGenerator = Effect.Effect<void, never, DatabaseService | ContextQueueService>;
+
+type StoryProps = ChatThreadProps & { generator?: MessageGenerator[]; delay?: number };
+
+const DefaultStory = ({ generator = [], delay = 0, ...props }: StoryProps) => {
+  const space = useSpace();
+  const queueDxn = useMemo(() => space?.queues.create().dxn, [space]);
+  const queue = useQueue<DataType.Message>(queueDxn);
+
+  // Generate messages.
+  useEffect(() => {
+    if (!space || !queue) {
+      return;
+    }
+
+    const fiber = Effect.runFork(
+      Effect.gen(function* () {
+        for (const step of generator) {
+          yield* step;
+          if (delay) {
+            yield* Effect.sleep(delay);
+          }
+        }
+      }).pipe(Effect.provide(Layer.mergeAll(DatabaseService.layer(space.db), ContextQueueService.layer(queue)))),
+    );
+
+    return () => {
+      void Effect.runPromise(Fiber.interrupt(fiber));
+    };
+  }, [space, queue, generator]);
+
+  // Set context.
+  const [controller, setController] = useState<ChatThreadController | null>(null);
+  useEffect(() => {
+    // controller?.setContext({ timestamp: Date.now() });
+  }, [controller]);
+
+  // TODO(burdon): Elsewhere PreviewProvider is implemented via the plugin-preview.
+  return (
+    <PreviewPopoverProvider
+      onLookup={async ({ label, ref }) => {
+        return { label, text: ref };
+      }}
+    >
+      <ChatThread {...props} messages={queue?.objects ?? []} ref={setController} />
+      <PreviewCard />
+    </PreviewPopoverProvider>
+  );
+};
+
+// TODO(burdon): Factor out.
+// TODO(burdon): Provide renderer for preview extension.
+const PreviewCard = () => {
+  const { target } = usePreviewPopover('PreviewCard');
+
+  return (
+    <Popover.Portal>
+      <Popover.Content onOpenAutoFocus={(event) => event.preventDefault()}>
+        <Popover.Viewport>
+          <Card.SurfaceRoot role='card--popover'>
+            <Card.Heading>{target?.label}</Card.Heading>
+            {target && <Card.Text classNames='truncate line-clamp-3'>{target.text}</Card.Text>}
+          </Card.SurfaceRoot>
+        </Popover.Viewport>
+        <Popover.Arrow />
+      </Popover.Content>
+    </Popover.Portal>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/ChatThread',
+  component: ChatThread,
+  render: DefaultStory,
+  decorators: [
+    withClientProvider({ createIdentity: true, createSpace: true, types: [DataType.Organization, DataType.Person] }),
+    withLayout({ fullscreen: true }),
+    withTheme,
+  ],
+  parameters: {
+    layout: 'fullscreen', // TODO(burdon): Replace withLayout.
+    translations,
+  },
+} satisfies Meta<typeof ChatThread>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    generator: createMessageGenerator(),
+  },
+};
+
+export const Delayed: Story = {
+  args: {
+    generator: createMessageGenerator(),
+    delay: 3_000,
+    fadeIn: true,
+    cursor: false,
+  },
+};

package/src/components/ChatThread/ChatThread.tsx

@@ -0,0 +1,93 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, {
+  type CSSProperties,
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useState,
+} from 'react';
+
+import { PublicKey } from '@dxos/keys';
+import { type Identity } from '@dxos/react-client/halo';
+import { type ThemedClassName } from '@dxos/react-ui';
+import { MarkdownStream, type MarkdownStreamController, type MarkdownStreamProps } from '@dxos/react-ui-components';
+import { mx } from '@dxos/react-ui-theme';
+import { type DataType } from '@dxos/schema';
+import { keyToFallback } from '@dxos/util';
+
+import { type ChatEvent } from '../Chat';
+
+import { blockToMarkdown, componentRegistry } from './registry';
+import { MessageSyncer } from './sync';
+
+export type ChatThreadController = Pick<MarkdownStreamController, 'setContext' | 'scrollToBottom'>;
+
+export type ChatThreadProps = ThemedClassName<
+  {
+    identity?: Identity;
+    messages?: DataType.Message[];
+    error?: Error;
+    onEvent?: (event: ChatEvent) => void;
+  } & Pick<MarkdownStreamProps, 'cursor' | 'fadeIn'>
+>;
+
+export const ChatThread = forwardRef<ChatThreadController | null, ChatThreadProps>(
+  ({ classNames, identity, messages = [], error, cursor = false, fadeIn = true, onEvent }, forwardedRef) => {
+    const userHue = useMemo(() => {
+      return identity?.profile?.data?.hue || keyToFallback(identity?.identityKey ?? PublicKey.random()).hue;
+    }, [identity]);
+
+    // Expose controller.
+    const [controller, setController] = useState<MarkdownStreamController | null>(null);
+    useImperativeHandle(forwardedRef, () => (controller ? controller : (null as any)), [controller]);
+
+    // Show error.
+    useEffect(() => {
+      controller?.scrollToBottom();
+    }, [controller, error]);
+
+    // Update document.
+    const syncer = useMemo(() => controller && new MessageSyncer(controller, blockToMarkdown), [controller]);
+    useEffect(() => {
+      syncer?.sync(messages);
+    }, [syncer, messages]);
+
+    // Event handler.
+    const handleEvent = useCallback<NonNullable<MarkdownStreamProps['onEvent']>>(
+      (ev) => {
+        switch (ev.type) {
+          case 'submit': {
+            ev.value &&
+              onEvent?.({
+                type: 'submit',
+                text: ev.value,
+              });
+            break;
+          }
+        }
+      },
+      [onEvent],
+    );
+
+    return (
+      <div
+        className={mx('flex bs-full is-full justify-center overflow-hidden', classNames)}
+        style={{ '--user-fill': `var(--dx-${userHue}Fill)` } as CSSProperties}
+      >
+        <MarkdownStream
+          ref={setController}
+          classNames='bs-full max-is-prose overflow-hidden'
+          registry={componentRegistry}
+          cursor={cursor}
+          fadeIn={fadeIn}
+          onEvent={handleEvent}
+        />
+      </div>
+    );
+  },
+);

package/src/components/ChatThread/Link.tsx

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type Space } from '@dxos/client/echo';
+import { Obj } from '@dxos/echo';
+import { type DXN } from '@dxos/keys';
+import { DxAnchor } from '@dxos/lit-ui/react';
+
+export type ObjectLinkProps = {
+  space: Space;
+  dxn: DXN;
+};
+
+export const ObjectLink = ({ space, dxn }: ObjectLinkProps) => {
+  const ref = useMemo(() => space.db.ref(dxn), [space, dxn.toString()]);
+
+  const title = Obj.getLabel(ref.target) ?? ref.target?.id ?? ref.dxn.toString();
+  return (
+    <DxAnchor rootclassname='dx-tag--anchor' refid={dxn.toString()}>
+      {title}
+    </DxAnchor>
+  );
+};

package/src/components/ChatThread/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './ChatThread';

package/src/components/ChatThread/reducers.ts

@@ -0,0 +1,151 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ContentBlock, type DataType } from '@dxos/schema';
+
+type Reducer<R, I> = (acc: R, value: I, idx: number) => R;
+
+/**
+ * Reducer that collapses related message blocks into single messages.
+ * For example, combines tool request/response pairs into a single message.
+ *
+ * Typical order:
+ * - message 0
+ *  - text
+ * - message 1
+ *  - text
+ *  - toolCall
+ *  - summary
+ * - message 2
+ *  - toolResult
+ * - message 3
+ *  - text
+ *  - summary
+ *
+ * Coverts to:
+ * - message 0
+ *  - text
+ * - message 1
+ *  - text
+ * - message 2
+ *  - toolCall
+ *  - toolResult
+ *  - summary
+ * - message 3
+ *  - text
+ *  - summary
+ */
+export const reduceMessages: Reducer<
+  {
+    messages: DataType.Message[];
+    current?: DataType.Message;
+    toolBlock?: boolean;
+    assistantMessages?: DataType.Message[];
+  },
+  DataType.Message
+> = ({ messages, current, toolBlock, assistantMessages = [] }, message) => {
+  // Treat tool calls as assistant messages.
+  let assistant = message?.sender.role === 'assistant';
+  let i = 0;
+  for (const block of message.blocks) {
+    switch (block._tag) {
+      // TODO(burdon): Preserve call tool title.
+      case 'toolCall': {
+        assistant = true;
+        if (!toolBlock) {
+          current = {
+            ...message,
+            id: [message.id, i++].join('_'),
+            blocks: [block],
+          };
+          messages.push(current);
+          toolBlock = true;
+        } else {
+          current!.blocks.push(block);
+        }
+        break;
+      }
+
+      case 'toolResult': {
+        assistant = true;
+        if (toolBlock) {
+          current!.blocks.push(block);
+        }
+        break;
+      }
+
+      case 'summary': {
+        assistant = true;
+        if (toolBlock) {
+          current!.blocks.push(block);
+        } else {
+          const summary = reduceSummary([...assistantMessages, message]);
+          current!.blocks.push(summary);
+        }
+        break;
+      }
+
+      default: {
+        assistant = message.sender.role === 'assistant';
+        current = {
+          ...message,
+          id: [message.id, i++].join('_'),
+          blocks: [block],
+        };
+        messages.push(current);
+        toolBlock = false;
+        break;
+      }
+    }
+  }
+
+  return {
+    messages,
+    current,
+    toolBlock,
+    assistantMessages: assistant ? [...assistantMessages, message] : undefined,
+  };
+};
+
+/**
+ * Accumulate token counts from all summary blocks in pending messages.
+ */
+const reduceSummary = (messages: DataType.Message[]): ContentBlock.Summary => {
+  let start: number | undefined;
+  return messages.reduce<ContentBlock.Summary>(
+    (acc, msg) => {
+      const time = new Date(msg.created).getTime();
+      if (!start) {
+        start = time;
+      }
+      msg.blocks.forEach((block) => {
+        switch (block._tag) {
+          case 'toolCall': {
+            acc.toolCalls = (acc.toolCalls ?? 0) + 1;
+            break;
+          }
+          case 'summary': {
+            acc.model = block.model;
+            if (block.usage) {
+              acc.message = block.message;
+              acc.usage = {
+                inputTokens: (acc.usage?.inputTokens ?? 0) + (block.usage.inputTokens ?? 0),
+                outputTokens: (acc.usage?.outputTokens ?? 0) + (block.usage.outputTokens ?? 0),
+                totalTokens: (acc.usage?.totalTokens ?? 0) + (block.usage.totalTokens ?? 0),
+              };
+              acc.duration = time - (start ?? time);
+            }
+            break;
+          }
+        }
+      });
+
+      return acc;
+    },
+    {
+      _tag: 'summary',
+      duration: 0,
+    } satisfies ContentBlock.Summary,
+  );
+};

package/src/components/ChatThread/registry.tsx

@@ -0,0 +1,189 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { log } from '@dxos/log';
+import {
+  PromptWidget,
+  ReferenceWidget,
+  SelectWidget,
+  SuggestionWidget,
+  SummaryWidget,
+  ToggleContainer,
+} from '@dxos/react-ui-components';
+import { type XmlWidgetProps, type XmlWidgetRegistry } from '@dxos/react-ui-editor';
+import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { ContentBlock, type DataType } from '@dxos/schema';
+
+import { ToolBlock } from '../ToolBlock';
+
+import { type BlockRenderer, type MessageThreadContext } from './sync';
+
+const Fallback = ({ _tag, ...props }: XmlWidgetProps<MessageThreadContext>) => {
+  return (
+    <ToggleContainer.Root classNames='rounded-sm'>
+      <ToggleContainer.Header classNames='bg-groupSurface'>{_tag}</ToggleContainer.Header>
+      <ToggleContainer.Content classNames='bg-modalSurface'>
+        <Json classNames='!p-2 text-sm' data={props} />
+      </ToggleContainer.Content>
+    </ToggleContainer.Root>
+  );
+};
+
+const getTextChild = (children: any[]): string | null => {
+  const child = children?.[0];
+  return typeof child === 'string' ? child : null;
+};
+
+/**
+ * Custom XML tags registry.
+ */
+export const componentRegistry: XmlWidgetRegistry = {
+  //
+  // Widgets
+  //
+
+  ['prompt' as const]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new PromptWidget(text) : null;
+    },
+  },
+  ['reference' as const]: {
+    block: false,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text && props.ref ? new ReferenceWidget(text, props.ref) : null;
+    },
+  },
+  ['select' as const]: {
+    block: true,
+    factory: (props) => {
+      const options = props.children
+        ?.map((option: any) => option._tag === 'option' && getTextChild(option.children))
+        .filter(Boolean);
+      return options?.length ? new SelectWidget(options) : null;
+    },
+  },
+  ['suggestion' as const]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new SuggestionWidget(text) : null;
+    },
+  },
+  ['summary' as const]: {
+    block: true,
+    factory: (props) => {
+      const text = getTextChild(props.children);
+      return text ? new SummaryWidget(text) : null;
+    },
+  },
+
+  //
+  // React
+  //
+
+  ['toolCall' as const]: {
+    block: true,
+    Component: ToolBlock,
+  },
+  ['toolResult' as const]: {
+    block: true,
+    Component: Fallback,
+  },
+  ['toolkit' as const]: {
+    block: true,
+    Component: Fallback,
+  },
+
+  //
+  // Fallback
+  //
+
+  ['json' as const]: {
+    block: true,
+    Component: Fallback,
+  },
+};
+
+/**
+ * Convert block to markdown.
+ */
+export const blockToMarkdown: BlockRenderer = (
+  context: MessageThreadContext,
+  message: DataType.Message,
+  block: ContentBlock.Any,
+) => {
+  let str = _blockToMarkdown(context, message, block);
+  if (str && !block.pending) {
+    return (str += '\n');
+  }
+
+  return str;
+};
+
+const _blockToMarkdown = (context: MessageThreadContext, message: DataType.Message, block: ContentBlock.Any) => {
+  log('blockToMarkdown', { block: JSON.stringify(block) });
+  switch (block._tag) {
+    case 'text': {
+      if (message.sender.role === 'user') {
+        return `\n<prompt>${block.text}</prompt>\n`;
+      } else {
+        const text = block.text.trim();
+        if (text.length > 0) {
+          return text;
+        }
+      }
+      break;
+    }
+
+    case 'suggestion': {
+      if (block.pending) {
+        return;
+      }
+      return `<suggestion>${block.text}</suggestion>`;
+    }
+    case 'select': {
+      if (block.pending || block.options.length === 0) {
+        return;
+      }
+
+      return `<select>${block.options.map((option) => `<option>${option}</option>`).join('')}</select>`;
+    }
+
+    // TODO(burdon): Need label.
+    case 'reference': {
+      return `<reference ref="${block.reference.dxn.toString()}">Ref</reference>`;
+    }
+
+    // case 'toolkit': {
+    //   return `<toolkit />`;
+    // }
+
+    case 'toolCall': {
+      context.updateWidget(block.toolCallId, {
+        blocks: [block],
+      });
+      return `<toolCall id="${block.toolCallId}" />`;
+    }
+    case 'toolResult': {
+      context.updateWidget(block.toolCallId, ({ blocks = [] }: { blocks: ContentBlock.Any[] }) => ({
+        blocks: [...blocks, block],
+      }));
+      break;
+    }
+
+    case 'summary': {
+      return `<summary>${ContentBlock.createSummaryMessage(block)}</summary>`;
+    }
+
+    // TODO(burdon): Need stable ID.
+    default: {
+      return `<json id="${message.id}">\n${JSON.stringify(block)}\n</json>`;
+    }
+  }
+};