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

package/src/components/Typewriter/assistant-extension.tsx

@@ -0,0 +1,142 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Diagnostic, linter } from '@codemirror/lint';
+import { type Extension, StateField } from '@codemirror/state';
+import { EditorView, type Tooltip, showTooltip } from '@codemirror/view';
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import * as Effect from 'effect/Effect';
+import * as Runtime from 'effect/Runtime';
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+
+import { unwrapExit } from '@dxos/effect';
+import { log } from '@dxos/log';
+
+import { AssistantToolbar } from './AssistantToolbar';
+
+export const assistant = (runtime: Runtime.Runtime<LanguageModel.LanguageModel>): Extension[] => {
+  return [
+    assistantState(runtime),
+    assistantLinter(runtime),
+    EditorView.baseTheme({
+      '.cm-tooltip-assistant': {
+        backgroundColor: 'transparent !important',
+        border: 'none !important',
+        padding: '0 !important',
+      },
+    }),
+  ];
+};
+
+//
+// Toolbar State & Tooltip
+//
+
+const assistantState = (runtime: Runtime.Runtime<LanguageModel.LanguageModel>) =>
+  StateField.define<Tooltip | null>({
+    create: () => null,
+    update: (tooltip, tr): Tooltip | null => {
+      if (tr.selection || tr.docChanged) {
+        const { from, to } = tr.state.selection.main;
+        if (from === to) {
+          return null;
+        } // No selection
+
+        // Check if we should show tooltip
+        // We return a tooltip object
+        return {
+          pos: from,
+          above: false,
+          strictSide: true,
+          create: (view) => {
+            const dom = document.createElement('div');
+            dom.classList.add('cm-tooltip-assistant');
+            const root = createRoot(dom);
+
+            root.render(React.createElement(AssistantToolbar, { view, runtime, from, to }));
+
+            return {
+              dom,
+              destroy: () => {
+                // Delay unmount to allow animations if needed, but for now just cleanup
+                setTimeout(() => root.unmount(), 0);
+              },
+            };
+          },
+        };
+      }
+      return tooltip;
+    },
+    provide: (f) => showTooltip.from(f),
+  });
+
+//
+// Linter
+//
+
+const assistantLinter = (runtime: Runtime.Runtime<LanguageModel.LanguageModel>) =>
+  linter(async (view) => {
+    const text = view.state.doc.toString();
+    if (text.length < 10) {
+      return [];
+    }
+
+    // Run proofreading effect
+    const prompt = `Proofread the following text. Identify typos and simple grammar mistakes. Return ONLY a valid JSON array of objects with fields: "original" (string), "replacement" (string), "context" (string, 3-5 words around match). Text: \n\n${text}`;
+
+    // We mocked the model behavior in the story, but here we assume the model returns a string.
+    // In a real implementation we would parse the JSON.
+    // For this refactor, we just wire it up.
+
+    // NOTE: This runs on every doc view update that triggers linter. Linter is debounced by default (750ms).
+
+    try {
+      const result = unwrapExit(
+        await Effect.gen(function* () {
+          const generated = yield* LanguageModel.generateText({ prompt });
+          return generated.text;
+        }).pipe(Runtime.runPromiseExit(runtime)),
+      );
+
+      // Parse result - assuming simpler mock response format for now or we build a robust parser
+      // For the purpose of this task (UX demo), we can assume the mock returns a specific format or we parse it.
+      // Let's assume the mock returns a JSON string.
+
+      let suggestions: any[] = [];
+      try {
+        // Find JSON in response
+        const match = result.match(/\[.*\]/s);
+        if (match) {
+          suggestions = JSON.parse(match[0]);
+        }
+      } catch {}
+
+      const diagnostics: Diagnostic[] = [];
+      for (const s of suggestions) {
+        // Naive finding of position
+        const idx = text.indexOf(s.original);
+        if (idx !== -1) {
+          diagnostics.push({
+            from: idx,
+            to: idx + s.original.length,
+            severity: 'info',
+            message: `Suggestion: ${s.replacement}`,
+            actions: [
+              {
+                name: 'Apply',
+                apply: (view, from, to) => {
+                  view.dispatch({ changes: { from, to, insert: s.replacement } });
+                },
+              },
+            ],
+          });
+        }
+      }
+      return diagnostics;
+    } catch (error) {
+      log.catch(error);
+      return [];
+    }
+  });

package/src/components/Typewriter/index.ts

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

package/src/components/index.ts

@@ -2,19 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
-import { lazy } from 'react';
-
-export * from './AssistantSettings';
 export * from './Chat';
-export * from './PromptSettings';
 export * from './TemplateEditor';
 export * from './Toolbox';
-
-// TODO(burdon): Lazy loading causes issues with Tabster.
-//  Repro: open assistant dialog then close.
-//  https://github.com/microsoft/fluentui/issues/34020
-
-export const ChatContainer = lazy(() => import('./ChatContainer'));
-export const ChatDialog = lazy(() => import('./ChatDialog'));
-export const SequenceContainer = lazy(() => import('./SequenceContainer'));
-export const TemplateContainer = lazy(() => import('./TemplateContainer'));

package/src/containers/AssistantSettings/AssistantSettings.tsx

@@ -0,0 +1,120 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React from 'react';
+
+import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/ai';
+import { Input, Select, useTranslation } from '@dxos/react-ui';
+import { Settings } 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;
+
+export type AssistantSettingsComponentProps = {
+  settings: Assistant.Settings;
+  onSettingsChange: (fn: (current: Assistant.Settings) => Assistant.Settings) => void;
+};
+
+export const AssistantSettings = ({ settings, onSettingsChange }: AssistantSettingsComponentProps) => {
+  const { t } = useTranslation(meta.id);
+
+  return (
+    <Settings.Root>
+      <Settings.Section title={t('settings title', { ns: meta.id })}>
+        <Settings.Group>
+          <Settings.ItemInput title={t('settings custom prompts label')}>
+            <Input.Switch
+              checked={!!settings.customPrompts}
+              onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, customPrompts: checked }))}
+            />
+          </Settings.ItemInput>
+
+          <Settings.ItemInput title={t('settings llm provider label')}>
+            <Select.Root
+              value={settings.llmProvider ?? 'edge'}
+              onValueChange={(value) => {
+                onSettingsChange((s) => ({
+                  ...s,
+                  llmProvider: value === DEFAULT_VALUE ? undefined : (value as any),
+                }));
+              }}
+            >
+              <Select.TriggerButton 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>
+          </Settings.ItemInput>
+
+          <Settings.ItemInput title={t('settings edge llm model label')}>
+            <Select.Root
+              value={settings.edgeModel ?? DEFAULT_VALUE}
+              onValueChange={(value) => {
+                onSettingsChange((s) => ({ ...s, edgeModel: value === DEFAULT_VALUE ? undefined : value }));
+              }}
+            >
+              <Select.TriggerButton 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>
+          </Settings.ItemInput>
+
+          <Settings.ItemInput title={t('settings ollama llm model label')}>
+            <Select.Root
+              value={settings.ollamaModel ?? DEFAULT_VALUE}
+              onValueChange={(value) => {
+                onSettingsChange((s) => ({ ...s, ollamaModel: value === DEFAULT_VALUE ? undefined : value }));
+              }}
+            >
+              <Select.TriggerButton 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>
+          </Settings.ItemInput>
+        </Settings.Group>
+      </Settings.Section>
+    </Settings.Root>
+  );
+};

package/src/containers/AssistantSettings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AssistantSettings } from './AssistantSettings';
+
+export default AssistantSettings;

package/src/containers/BlueprintArticle/BlueprintArticle.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { type Blueprint } from '@dxos/blueprints';
+import { Panel, Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '../../components';
+
+export type BlueprintArticleProps = SurfaceComponentProps<Blueprint.Blueprint>;
+
+export const BlueprintArticle = ({ role, attendableId, subject }: BlueprintArticleProps) => {
+  const { hasAttention } = useAttention(attendableId);
+
+  return (
+    <Panel.Root role={role} classNames='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/BlueprintArticle/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BlueprintArticle } from './BlueprintArticle';
+
+export default BlueprintArticle;

package/src/containers/ChatCompanion/ChatCompanion.tsx

@@ -0,0 +1,227 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Array from 'effect/Array';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { useAtomCapability, useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { getSpace } from '@dxos/client/echo';
+import { DXN, Filter, Obj, Query, Ref } from '@dxos/echo';
+import { SpaceOperation } from '@dxos/plugin-space/types';
+import { useQuery } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { type ChatEvent } from '../../components';
+import { useBlueprintRegistry, useContextBinder } from '../../hooks';
+import { Assistant, AssistantCapabilities, AssistantOperation } from '../../types';
+import ChatContainer from '../ChatContainer';
+
+export type ChatCompanionProps = {
+  role?: string;
+  data: {
+    attendableId: string;
+    subject: Chat.Chat | 'assistant-chat';
+    companionTo: Obj.Unknown;
+  };
+};
+
+export const ChatCompanion = forwardRef<HTMLDivElement, ChatCompanionProps>(
+  ({ role, data }: ChatCompanionProps, forwardedRef) => {
+    const { invokePromise } = useOperationInvoker();
+    const blueprintRegistry = useBlueprintRegistry();
+    const companionTo = data.companionTo;
+
+    const space = getSpace(companionTo);
+    const [chat, setChat] = useState(data.subject === 'assistant-chat' ? undefined : data.subject);
+
+    // Watch the state atom directly to detect when plus button clears the chat selection.
+    const state = useAtomCapability(AssistantCapabilities.State);
+    const companionToId = Obj.getDXN(companionTo).toString();
+    const currentChatState = state?.currentChat[companionToId];
+
+    // Track if initial setup has been done (to distinguish initial mount from plus button click).
+    // Reset when companionTo changes.
+    const initialSetupDoneRef = useRef(false);
+    const prevCompanionToIdRef = useRef(companionToId);
+    if (prevCompanionToIdRef.current !== companionToId) {
+      initialSetupDoneRef.current = false;
+      prevCompanionToIdRef.current = companionToId;
+    }
+
+    // Sync local chat state with the state atom.
+    // When currentChatState is undefined (plus button clicked), reset local chat.
+    // When data.subject is a Chat object, use it directly.
+    // When currentChatState is a different chat, fetch and set it.
+    useEffect(() => {
+      // If state says no chat selected AND current chat is persisted, reset local state (handles plus button click).
+      // Don't reset in-memory chats - they're expected to have currentChatState === undefined.
+      if (!currentChatState && chat && getSpace(chat)) {
+        setChat(undefined);
+      } else if (data.subject !== 'assistant-chat') {
+        // If data.subject is a Chat object (resolved from graph), use it.
+        setChat(data.subject);
+      } else if (currentChatState && space) {
+        // currentChatState is set but graph couldn't resolve it - fetch manually.
+        const currentChatDxnStr = chat ? Obj.getDXN(chat).toString() : undefined;
+        if (currentChatState !== currentChatDxnStr) {
+          // Parse DXN and fetch the chat object from the database.
+          const parsedDxn = DXN.tryParse(currentChatState);
+          if (parsedDxn) {
+            const chatRef = space.db.makeRef(parsedDxn);
+            const resolvedChat = chatRef?.target;
+            if (Obj.instanceOf(Assistant.Chat, resolvedChat)) {
+              setChat(resolvedChat);
+            }
+          }
+        }
+      }
+    }, [currentChatState, data.subject, space, chat]);
+
+    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;
+      }
+
+      // Only query for existing chats on initial mount, not when plus button is clicked.
+      if (!initialSetupDoneRef.current) {
+        // Query for existing companion chats linked to this object.
+        const existingChats = await space.db
+          .query(Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source())
+          .run();
+
+        initialSetupDoneRef.current = true;
+
+        // Use existing chat if found on initial mount.
+        if (existingChats.length > 0) {
+          const existingChat = existingChats.at(-1) as Assistant.Chat;
+          setChat(existingChat);
+          await invokePromise(AssistantOperation.SetCurrentChat, { companionTo, chat: existingChat });
+          return;
+        }
+      }
+
+      // Create chat in-memory only - it will be added to space on first message.
+      const { data: createResult } = await invokePromise(AssistantOperation.CreateChat, {
+        db: space.db,
+        addToSpace: false,
+      });
+      setChat(createResult?.object);
+    }, [chat, space, companionTo, invokePromise]);
+
+    // Add chat to space and create relation when user submits the first message.
+    const handleEvent = useCallback(
+      async (event: ChatEvent) => {
+        if (!chat || !space) {
+          return;
+        }
+
+        // If chat is not in space yet, persist it on first submit.
+        if (event.type === 'submit' && !getSpace(chat)) {
+          await invokePromise(SpaceOperation.AddObject, {
+            object: chat,
+            target: space.db,
+            hidden: true,
+          });
+          await invokePromise(SpaceOperation.AddRelation, {
+            db: space.db,
+            schema: Chat.CompanionTo,
+            source: chat,
+            target: companionTo,
+          });
+          await invokePromise(AssistantOperation.SetCurrentChat, {
+            companionTo,
+            chat,
+          });
+        }
+      },
+      [chat, space, companionTo, invokePromise],
+    );
+
+    const metadata = useCapabilities(AppCapabilities.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?.db, 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 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, { deep: true }));
+      }
+    }, [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}
+        attendableId={data.attendableId}
+        space={space}
+        subject={chat}
+        companionTo={companionTo}
+        onEvent={handleEvent}
+        ref={forwardedRef}
+      />
+    );
+  },
+);

package/src/containers/ChatCompanion/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatCompanion } from './ChatCompanion';
+
+export default ChatCompanion;

package/src/containers/ChatContainer/ChatContainer.tsx

@@ -0,0 +1,92 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useEffect, useRef } from 'react';
+
+import { Capabilities } from '@dxos/app-framework';
+import { useAtomCapability, useCapability } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { type Space, getSpace } from '@dxos/client/echo';
+import { type Obj } from '@dxos/echo';
+import { Panel } from '@dxos/react-ui';
+import { getParentId } from '@dxos/react-ui-attention';
+
+import { Chat as ChatComponent, type ChatRootProps } from '../../components';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../../hooks';
+import { AssistantCapabilities, type ChatType } from '../../types';
+
+export type ChatContainerProps = SurfaceComponentProps<
+  ChatType.Chat | undefined,
+  {
+    space?: Space;
+    companionTo?: Obj.Unknown;
+  } & Pick<ChatRootProps, 'onEvent'>
+>;
+
+export const ChatContainer = forwardRef<HTMLDivElement, ChatContainerProps>((props, forwardedRef) => {
+  const { role, attendableId, subject: chat, space: spaceProp, companionTo, onEvent } = props;
+  const parentId = attendableId ? getParentId(attendableId) : undefined;
+  const space = spaceProp ?? getSpace(chat);
+  const settings = useAtomCapability(AssistantCapabilities.Settings);
+  const services = useChatServices({ id: space?.id, chat });
+  const [online, setOnline] = useOnline();
+  const { preset, ...chatProps } = usePresets(online);
+  const blueprintRegistry = useBlueprintRegistry();
+  const processor = useChatProcessor({
+    space,
+    chat,
+    preset,
+    services,
+    blueprintRegistry,
+    settings,
+  });
+
+  const registry = useCapability(Capabilities.AtomRegistry);
+  const stateAtom = useCapability(AssistantCapabilities.State);
+  const pendingSubmitted = useRef(false);
+  useEffect(() => {
+    if (!processor || !attendableId || pendingSubmitted.current) {
+      return;
+    }
+
+    const state = registry.get(stateAtom);
+    const pendingPrompt = state.pendingPrompts[attendableId];
+    if (pendingPrompt) {
+      pendingSubmitted.current = true;
+      registry.update(stateAtom, (current) => {
+        const { [attendableId]: _, ...rest } = current.pendingPrompts;
+        return { ...current, pendingPrompts: rest };
+      });
+      void processor.request({ message: pendingPrompt });
+    }
+  }, [processor, attendableId, registry, stateAtom]);
+
+  if (!processor) {
+    return null;
+  }
+
+  return (
+    <ChatComponent.Root db={space?.db} chat={chat} processor={processor} onEvent={onEvent}>
+      <Panel.Root role={role} classNames='dx-document' ref={forwardedRef}>
+        <Panel.Toolbar>
+          <ChatComponent.Toolbar attendableId={parentId} companionTo={companionTo} />
+        </Panel.Toolbar>
+        <Panel.Content>
+          <ChatComponent.Viewport>
+            <ChatComponent.Thread />
+            <div role='none' className='p-4'>
+              <ChatComponent.Prompt
+                {...chatProps}
+                outline
+                preset={preset?.id}
+                online={online}
+                onOnlineChange={setOnline}
+              />
+            </div>
+          </ChatComponent.Viewport>
+        </Panel.Content>
+      </Panel.Root>
+    </ChatComponent.Root>
+  );
+});

package/src/containers/ChatContainer/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ChatContainer } from './ChatContainer';
+
+export default ChatContainer;