@dxos/plugin-assistant 0.8.4-main.4a85c3132b → 0.8.4-main.51f1e5ca51

package/src/components/ChatPrompt/ChatPrompt.tsx

@@ -0,0 +1,179 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Option from 'effect/Option';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+
+import { type Chat } from '@dxos/assistant-toolkit';
+import { type Event } from '@dxos/async';
+import { type Database } from '@dxos/echo';
+import { type Merge } from '@dxos/effect';
+import { useVoiceInput } from '@dxos/plugin-transcription';
+import { Input, type ThemedClassName, useDynamicRef, useTranslation } from '@dxos/react-ui';
+import { ChatEditor, type ChatEditorController, type ChatEditorProps } from '@dxos/react-ui-chat';
+import { mx } from '@dxos/ui-theme';
+
+import { useChatKeymapExtensions } from '#hooks';
+import { meta } from '#meta';
+
+import { type AiChatProcessor } from '../../processor';
+import { type ChatEvent } from '../Chat/events';
+import { ChatActions, type ChatActionsProps } from './ChatActions';
+import { ChatOptions } from './ChatOptions';
+import { type ChatPresetsProps } from './ChatPresets';
+import { ChatReferences } from './ChatReferences';
+import { ChatStatusIndicator } from './ChatStatusIndicator';
+
+export type ChatPromptProps = ThemedClassName<
+  Merge<
+    {
+      outline?: boolean;
+      settings?: boolean;
+      expandable?: boolean;
+      chat?: Chat.Chat;
+      db?: Database.Database;
+      processor: AiChatProcessor;
+      event: Event<ChatEvent>;
+      online?: boolean;
+      placeholder?: ChatEditorProps['placeholder'];
+      onOnlineChange?: (online: boolean) => void;
+      onPresetChange?: ChatPresetsProps['onChange'];
+    },
+    Omit<ChatPresetsProps, 'onChange'>
+  >
+>;
+
+export const ChatPrompt = ({
+  classNames,
+  outline,
+  chat,
+  db,
+  processor,
+  event,
+  online,
+  placeholder,
+  onOnlineChange,
+  onPresetChange,
+  settings = true,
+  presets,
+  preset,
+}: ChatPromptProps) => {
+  const { t } = useTranslation(meta.id);
+
+  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((ev) => {
+      switch (ev.type) {
+        case 'update-prompt':
+          if (!editorRef.current?.getText()?.length) {
+            editorRef.current?.setText(ev.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 = useChatKeymapExtensions({ event });
+
+  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 rounded-sm! border border-subdued-separator transition transition-border [&:has(.cm-content:focus)]:border-separator',
+        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 p-1.5'>
+          <ChatOptions
+            chat={chat}
+            db={db}
+            blueprintRegistry={processor.blueprintRegistry}
+            context={processor.context}
+            preset={preset}
+            presets={presets}
+            onPresetChange={onPresetChange}
+          />
+
+          <div role='none' className='flex h-8 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>
+  );
+};
+
+ChatPrompt.displayName = 'Chat.Prompt';

package/src/components/ChatPrompt/ChatReferences.tsx

@@ -10,8 +10,8 @@ import { Annotation, type Database, Obj } from '@dxos/echo';
 import { Icon, IconButton, type Label, type ThemedClassName, toLocalizedString, useTranslation } from '@dxos/react-ui';
 import { getStyles, mx } from '@dxos/ui-theme';
 
-import { useContextObjects } from '../../hooks';
-import { meta } from '../../meta';
+import { useContextObjects } from '#hooks';
+import { meta } from '#meta';
 
 export type ChatReferencesProps = ThemedClassName<{
   context: AiContextBinder;
@@ -27,7 +27,7 @@ export const ChatReferences = ({ classNames, context, db }: ChatReferencesProps)
       {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);
+        const label: Label = Obj.getLabel(obj) ?? (typename ? ['object-name.placeholder', { ns: typename }] : obj.id);
         const { icon, hue } = Option.fromNullable(Obj.getSchema(obj)).pipe(
           Option.flatMap(Annotation.IconAnnotation.get),
           Option.getOrElse(() => ({ icon: DEFAULT_OBJECT_ICON, hue: undefined as string | undefined })),
@@ -41,7 +41,7 @@ export const ChatReferences = ({ classNames, context, db }: ChatReferencesProps)
               icon='ph--x--bold'
               iconOnly
               variant='ghost'
-              label={t('remove object in context label')}
+              label={t('remove-object.label')}
               classNames='p-0 hover:bg-transparent'
               size={3}
               onClick={() => onUpdateObject?.(dxn, false)}

package/src/components/ChatPrompt/ChatStatus.tsx

@@ -0,0 +1,123 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React, { useEffect, useMemo, useState } from 'react';
+
+import { type ThemedClassName } from '@dxos/react-ui';
+import { ChatStatus as NaturalChatStatus, formatElapsed } from '@dxos/react-ui-chat';
+import { Matrix } from '@dxos/react-ui-sfx';
+import { type ContentBlock } from '@dxos/types';
+import { Unit } from '@dxos/util';
+
+import { type ChatRequestTiming, useChatContext } from '../Chat/context';
+
+const CHAT_STREAM_STATUS_NAME = 'Chat.StreamStatus';
+const TICK_MS = 1_000;
+
+export type ChatStreamStatusProps = ThemedClassName<{
+  icon?: boolean;
+}>;
+
+/**
+ * Live status pill rendered at the bottom of the chat thread.
+ *
+ * The block-widget host re-mounts this component each time wire's drip queue toggles
+ * (`wireDrainingEffect`) — so all visible state is derived from chat-context values that
+ * survive the unmount: the latest `stats` block on the chat context's `messages` for token counts,
+ * and `requestTiming` (start/end wall-clock timestamps) for the elapsed value.
+ *
+ * Shows:
+ * - elapsed seconds since the most recent request started (frozen at end-of-request)
+ * - last completed turn's output token count (from the most recent `stats` content block)
+ * - cumulative session total tokens across all `stats` content blocks
+ */
+export const ChatStatus = ({ classNames, icon }: ChatStreamStatusProps) => {
+  // Read `messages` from the chat context (combines `useQuery(queue)` + the processor's
+  // pending atom) rather than `processor.messages` directly — the latter only contains
+  // blocks streamed via the ephemeral `PartialBlock` channel, while finalized blocks
+  // (including the per-turn `stats` block we read for token counts) are submitted to the
+  // feed via `_submitMessage` and only show up through `useQuery`.
+  const { messages, requestTiming } = useChatContext(CHAT_STREAM_STATUS_NAME);
+
+  const { lastOutputTokens, sessionTotalTokens } = useMemo(() => {
+    let last: number | undefined;
+    let total = 0;
+    for (const message of messages) {
+      for (const block of message.blocks) {
+        if (isStats(block) && block.usage) {
+          last = block.usage.outputTokens;
+          total += block.usage.totalTokens ?? 0;
+        }
+      }
+    }
+    return { lastOutputTokens: last, sessionTotalTokens: total };
+  }, [messages]);
+
+  const isRunning = requestTiming != null && requestTiming.endedAt == null;
+  const show = requestTiming || lastOutputTokens || sessionTotalTokens > 0;
+  if (!show) {
+    return null;
+  }
+
+  return (
+    <NaturalChatStatus.Root defaultRunning={false} classNames={['py-2 gap-2 text-sm', classNames]}>
+      {icon && (
+        <NaturalChatStatus.Icon>
+          <Matrix
+            classNames='w-5 h-5'
+            dotClassNames='bg-primary-500'
+            dim={4}
+            dotSize={3}
+            count={10}
+            interval={500}
+            active={isRunning}
+          />
+        </NaturalChatStatus.Icon>
+      )}
+      {show && (
+        <div role='none' className='flex items-center'>
+          {requestTiming && (
+            <NaturalChatStatus.Text>
+              <Elapsed timing={requestTiming} />
+            </NaturalChatStatus.Text>
+          )}
+          {lastOutputTokens != null && (
+            <>
+              {requestTiming && <NaturalChatStatus.Separator />}
+              <NaturalChatStatus.Text>↓ {Unit.Thousand(lastOutputTokens).toString()}</NaturalChatStatus.Text>
+            </>
+          )}
+          {sessionTotalTokens > 0 && (
+            <>
+              {(requestTiming || lastOutputTokens != null) && <NaturalChatStatus.Separator />}
+              <NaturalChatStatus.Text>Σ {Unit.Thousand(sessionTotalTokens).toString()}</NaturalChatStatus.Text>
+            </>
+          )}
+        </div>
+      )}
+    </NaturalChatStatus.Root>
+  );
+};
+
+/**
+ * Wall-clock-derived elapsed display. Tick interval forces a re-render every second while
+ * the request is active so the displayed value advances; once `endedAt` is set, the value
+ * is frozen and the interval is no longer scheduled.
+ */
+const Elapsed = ({ timing }: { timing: ChatRequestTiming }) => {
+  const isRunning = timing.endedAt == null;
+  const [now, setNow] = useState(Date.now());
+  useEffect(() => {
+    if (!isRunning) {
+      return;
+    }
+
+    const id = setInterval(() => setNow(Date.now()), TICK_MS);
+    return () => clearInterval(id);
+  }, [isRunning]);
+
+  return <>{formatElapsed((timing.endedAt ?? now) - timing.startedAt)}</>;
+};
+
+const isStats = (block: ContentBlock.Any): block is ContentBlock.Stats => block._tag === 'stats';

package/src/components/ChatPrompt/index.ts

@@ -5,5 +5,7 @@
 export * from './ChatActions';
 export * from './ChatOptions';
 export * from './ChatPresets';
+export * from './ChatPrompt';
 export * from './ChatReferences';
 export * from './ChatStatusIndicator';
+export * from './ChatStatus';

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

@@ -0,0 +1,95 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Database, Filter, Obj } from '@dxos/echo';
+import { DxAnchor } from '@dxos/lit-ui/react';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
+import { Organization } from '@dxos/types';
+
+/**
+ * Production-style click → popover demo.
+ *
+ * Wires up the same chain Composer uses:
+ * - `<DxAnchor dxn=…>label</DxAnchor>` fires `DxAnchorActivate` on click.
+ * - `PreviewPlugin`'s `preview-popover` capability listens for the event, resolves the DXN
+ *   to a real ECHO object via `space.db.makeRef(dxn).load()`, then invokes
+ *   `LayoutOperation.UpdatePopover`.
+ * - `StorybookPlugin` provides both the `LayoutOperation.UpdatePopover` handler (mutating
+ *   the layout-state atom) and the `<Layout>` shell that renders the popover via
+ *   `<Surface.Surface type={AppSurface.Card} data={popoverContent}>`.
+ * - `PreviewPlugin` also registers Card-role surfaces (Organization, Person, Task, …); the
+ *   Surface system picks the matching one based on the resolved object's type.
+ *
+ * Click the anchor — the matching Card surface (from plugin-preview) renders inside the
+ * popover, anchored to the trigger.
+ */
+const DefaultStory = () => {
+  const [space] = useSpaces();
+  const [organization] = useQuery(space?.db, Filter.type(Organization.Organization));
+  if (!organization) {
+    return <Loading />;
+  }
+
+  const dxn = Obj.getDXN(organization).toString();
+  return (
+    <div role='none' className='flex flex-col gap-2 p-4'>
+      <p>
+        Click{' '}
+        <DxAnchor className='dx-tag--anchor' dxn={dxn}>
+          {organization.name}
+        </DxAnchor>{' '}
+        to open the popover.
+      </p>
+    </div>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/components/ChatThread/Anchor',
+  render: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'centered' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
+        PreviewPlugin(),
+        ClientPlugin({
+          types: [Organization.Organization],
+          onClientInitialized: Effect.fnUntraced(function* ({ client }) {
+            const { personalSpace } = yield* initializeIdentity(client);
+            yield* Effect.gen(function* () {
+              yield* Database.add(
+                Obj.make(Organization.Organization, {
+                  name: 'DXOS',
+                  website: 'https://dxos.org',
+                  description: 'A decentralized network for collaborative applications.',
+                }),
+              );
+            }).pipe(Effect.provide(Database.layer(personalSpace.db)));
+          }),
+        }),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'centered',
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

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

@@ -6,39 +6,37 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 import * as Effect from 'effect/Effect';
 import * as Fiber from 'effect/Fiber';
 import * as Layer from 'effect/Layer';
-import React, { type CSSProperties, useEffect, useMemo, useState } from 'react';
+import React, { useEffect, useMemo, useState } from 'react';
 
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { ContextQueueService } from '@dxos/compute';
 import { Database } from '@dxos/echo';
 import { runAndForwardErrors } from '@dxos/effect';
-import { ContextQueueService } 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 { Card } from '@dxos/react-ui';
-import { withLayout, withTheme } from '@dxos/react-ui/testing';
-import { MarkdownStream } from '@dxos/react-ui-components';
-import { EditorPreviewProvider, useEditorPreview } from '@dxos/react-ui-editor';
-import { render } from '@dxos/storybook-utils';
-import { type Message, Organization, Person } from '@dxos/types';
-
-import { createMessageGenerator } from '../../testing';
-import { translations } from '../../translations';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { type Queue, useSpaces } from '@dxos/react-client/echo';
+import { EditorPreviewProvider } from '@dxos/react-ui-editor';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { Message, Organization, Person } from '@dxos/types';
+
+import { createMessageGenerator } from '#testing';
+import { translations } from '#translations';
 
 import { ChatThread, type ChatThreadProps } from './ChatThread';
-import { componentRegistry } from './registry';
-import TEXT from './testing/thread.md?raw';
 
-faker.seed(1);
+random.seed(1);
 
 type MessageGenerator = Effect.Effect<void, never, Database.Service | ContextQueueService>;
 
-type StoryProps = { generator?: MessageGenerator[]; delay?: number; wait?: boolean } & ChatThreadProps;
+type DefaultStoryProps = { generator?: MessageGenerator[]; delay?: number; wait?: boolean } & ChatThreadProps;
 
-const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: StoryProps) => {
-  const space = useSpace();
-  const queueDxn = useMemo(() => space?.queues.create().dxn, [space]);
-  const queue = useQueue<Message.Message>(queueDxn);
+const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const queue = useMemo<Queue<Message.Message> | undefined>(() => space?.queues.create(), [space]);
+  const messages = useQueueMessages(queue);
   const [done, setDone] = useState(false);
 
   // Generate messages.
@@ -55,6 +53,7 @@ const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: StoryProps)
             yield* Effect.sleep(delay);
           }
         }
+
         setDone(true);
       }).pipe(Effect.provide(Layer.mergeAll(Database.layer(space.db), ContextQueueService.layer(queue)))),
     );
@@ -62,60 +61,67 @@ const DefaultStory = ({ generator = [], delay = 0, wait, ...props }: StoryProps)
     return () => {
       void runAndForwardErrors(Fiber.interrupt(fiber));
     };
-  }, [space, queue, generator]);
+  }, [space, queue, generator, delay]);
 
   if (wait && !done) {
-    return null;
+    return <Loading data={{ wait, done }} />;
   }
 
   return (
     <EditorPreviewProvider onLookup={async ({ dxn, label }) => ({ label, text: dxn })}>
-      <ChatThread {...props} messages={queue?.objects} />
-      <PreviewCard />
+      <ChatThread {...props} messages={messages} />
     </EditorPreviewProvider>
   );
 };
 
-const PreviewCard = () => {
-  const { target } = useEditorPreview('PreviewCard');
+const useQueueMessages = (queue?: Queue<Message.Message>) => {
+  const [messages, setMessages] = useState<Message.Message[]>([]);
 
-  return (
-    <Popover.Portal>
-      <Popover.Content onOpenAutoFocus={(event) => event.preventDefault()}>
-        <Popover.Viewport>
-          <Card.Root>
-            <Card.Heading>{target?.label}</Card.Heading>
-            {target && <Card.Text classNames='truncate line-clamp-3'>{target.text}</Card.Text>}
-          </Card.Root>
-        </Popover.Viewport>
-        <Popover.Arrow />
-      </Popover.Content>
-    </Popover.Portal>
-  );
+  useEffect(() => {
+    if (!queue) {
+      setMessages([]);
+      return;
+    }
+
+    const update = () => setMessages([...queue.objects]);
+    update();
+    return queue.subscribe(update);
+  }, [queue]);
+
+  return messages;
 };
 
 const meta = {
   title: 'plugins/plugin-assistant/components/ChatThread',
   component: ChatThread,
-  render: render(DefaultStory),
+  render: DefaultStory,
   decorators: [
     withTheme(),
     withLayout({ layout: 'column' }),
-    withClientProvider({
-      createIdentity: true,
-      createSpace: true,
-      types: [Organization.Organization, Person.Person],
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
+        PreviewPlugin(),
+        ClientPlugin({
+          types: [Organization.Organization, Person.Person],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+            }),
+        }),
+      ],
     }),
   ],
   parameters: {
     layout: 'fullscreen',
     translations,
   },
-} satisfies Meta<StoryProps>;
+} satisfies Meta<DefaultStoryProps>;
 
 export default meta;
 
-type Story = StoryObj<StoryProps>;
+type Story = StoryObj<DefaultStoryProps>;
 
 export const Default: Story = {
   args: {
@@ -127,24 +133,11 @@ export const Default: Story = {
 export const Delayed: Story = {
   args: {
     generator: createMessageGenerator(),
-    delay: 1_000,
-    fadeIn: true,
-    cursor: false,
+    delay: 500,
+    options: {
+      autoScroll: true,
+      typewriter: true,
+      cursor: true,
+    },
   },
 };
-
-export const Raw: Story = {
-  render: () => (
-    <div className='contents' style={{ '--user-fill': 'var(--color-amber-fill)' } as CSSProperties}>
-      <MarkdownStream content={TEXT} />
-    </div>
-  ),
-};
-
-export const Static: Story = {
-  render: () => (
-    <div className='contents' style={{ '--user-fill': 'var(--color-amber-fill)' } as CSSProperties}>
-      <MarkdownStream content={TEXT} registry={componentRegistry} />
-    </div>
-  ),
-};