@dxos/plugin-assistant 0.8.4-main.3c1ae3b → 0.8.4-main.3eb6e50203

package/src/capabilities/{repair.ts → repair/repair.ts}

@@ -2,19 +2,23 @@
 // Copyright 2025 DXOS.org
 //
 
-import { contributes } from '@dxos/app-framework';
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Chat } from '@dxos/assistant-toolkit';
 import { Blueprint, Prompt } from '@dxos/blueprints';
 import { Obj, Ref, Type } from '@dxos/echo';
 import { SpaceCapabilities } from '@dxos/plugin-space';
 import { type Space } from '@dxos/react-client/echo';
 import { Collection } from '@dxos/schema';
 
-import { Assistant } from '../types';
-
-export default () =>
-  contributes(SpaceCapabilities.Repair, async ({ space }) => {
-    await ensureSystemCollections(space);
-  });
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(SpaceCapabilities.Repair, async ({ space }) => {
+      await ensureSystemCollections(space);
+    }),
+  ),
+);
 
 /**
  * Ensure the root collection has system collections for AI Chats, Blueprints, and Prompts.
@@ -27,23 +31,32 @@ const ensureSystemCollections = async (space: Space) => {
 
   const objects = await Promise.all(rootCollection.objects.map((ref) => ref.load()));
   const chats = objects.find(
-    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Assistant.Chat.typename,
+    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Chat.Chat.typename,
   );
   if (!chats) {
-    rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Assistant.Chat.typename })));
+    const chatsCollectionRef = Ref.make(Collection.makeManaged({ key: Chat.Chat.typename }));
+    Obj.change(rootCollection, (c) => {
+      c.objects.push(chatsCollectionRef);
+    });
   }
 
   const blueprints = objects.find(
     (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Blueprint.Blueprint.typename,
   );
   if (!blueprints) {
-    rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Blueprint.Blueprint.typename })));
+    const blueprintsCollectionRef = Ref.make(Collection.makeManaged({ key: Blueprint.Blueprint.typename }));
+    Obj.change(rootCollection, (c) => {
+      c.objects.push(blueprintsCollectionRef);
+    });
   }
 
   const prompts = objects.find(
     (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Type.getTypename(Prompt.Prompt),
   );
   if (!prompts) {
-    rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Type.getTypename(Prompt.Prompt) })));
+    const promptsCollectionRef = Ref.make(Collection.makeManaged({ key: Type.getTypename(Prompt.Prompt) }));
+    Obj.change(rootCollection, (c) => {
+      c.objects.push(promptsCollectionRef);
+    });
   }
 };

package/src/capabilities/settings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const Settings = Capability.lazy('Settings', () => import('./settings'));

package/src/capabilities/settings/settings.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '../../meta';
+import { Assistant, AssistantCapabilities } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Assistant.Settings,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(AssistantCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Assistant.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/state/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const AssistantState = Capability.lazy('AssistantState', () => import('./state'));

package/src/capabilities/state/state.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '../../meta';
+import { AssistantCapabilities } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    // NOTE: This needs to be a chat object rather than a string id to avoid a query race.
+    // TODO(wittjosiah): Handle serialization and hydration for this so it can be cached.
+    const stateAtom = createKvsStore({
+      key: meta.id,
+      schema: AssistantCapabilities.StateSchema,
+      defaultValue: () => ({
+        currentChat: {},
+      }),
+    });
+
+    return Capability.contributes(AssistantCapabilities.State, stateAtom);
+  }),
+);

package/src/capabilities/toolkit/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const Toolkit = Capability.lazy('Toolkit', () => import('./toolkit'));

package/src/capabilities/toolkit/toolkit.ts

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

package/src/components/AssistantSettings/AssistantSettings.tsx

@@ -6,7 +6,7 @@ import React from 'react';
 
 import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/ai';
 import { Input, Select, useTranslation } from '@dxos/react-ui';
-import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
+import { Settings } from '@dxos/react-ui-form';
 
 import { meta } from '../../meta';
 import { type Assistant, LLM_PROVIDERS } from '../../types';
@@ -20,25 +20,33 @@ const LLM_PROVIDER_LABELS = {
   lmstudio: 'LM Studio',
 } as const;
 
-export const AssistantSettings = ({ settings }: { settings: Assistant.Settings }) => {
+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 (
-    <ControlPage>
-      <ControlSection title={t('settings title', { ns: meta.id })}>
-        <ControlGroup>
-          <ControlItemInput title={t('settings custom prompts label')}>
+    <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) => (settings.customPrompts = checked)}
+              onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, customPrompts: checked }))}
             />
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('settings llm provider label')}>
+          <Settings.ItemInput title={t('settings llm provider label')}>
             <Select.Root
               value={settings.llmProvider ?? 'edge'}
               onValueChange={(value) => {
-                settings.llmProvider = value === DEFAULT_VALUE ? undefined : (value as any);
+                onSettingsChange((s) => ({
+                  ...s,
+                  llmProvider: value === DEFAULT_VALUE ? undefined : (value as any),
+                }));
               }}
             >
               <Select.TriggerButton placeholder={t('settings llm provider label')} />
@@ -56,13 +64,13 @@ export const AssistantSettings = ({ settings }: { settings: Assistant.Settings }
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('settings edge llm model label')}>
+          <Settings.ItemInput title={t('settings edge llm model label')}>
             <Select.Root
               value={settings.edgeModel ?? DEFAULT_VALUE}
               onValueChange={(value) => {
-                settings.edgeModel = value === DEFAULT_VALUE ? undefined : value;
+                onSettingsChange((s) => ({ ...s, edgeModel: value === DEFAULT_VALUE ? undefined : value }));
               }}
             >
               <Select.TriggerButton placeholder={t('settings default llm model label')} />
@@ -80,13 +88,13 @@ export const AssistantSettings = ({ settings }: { settings: Assistant.Settings }
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('settings ollama llm model label')}>
+          <Settings.ItemInput title={t('settings ollama llm model label')}>
             <Select.Root
               value={settings.ollamaModel ?? DEFAULT_VALUE}
               onValueChange={(value) => {
-                settings.ollamaModel = value === DEFAULT_VALUE ? undefined : value;
+                onSettingsChange((s) => ({ ...s, ollamaModel: value === DEFAULT_VALUE ? undefined : value }));
               }}
             >
               <Select.TriggerButton placeholder={t('settings default llm model label')} />
@@ -104,9 +112,9 @@ export const AssistantSettings = ({ settings }: { settings: Assistant.Settings }
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
-        </ControlGroup>
-      </ControlSection>
-    </ControlPage>
+          </Settings.ItemInput>
+        </Settings.Group>
+      </Settings.Section>
+    </Settings.Root>
   );
 };

package/src/components/BlueprintArticle.tsx

@@ -4,25 +4,24 @@
 
 import React from 'react';
 
-import { type SurfaceComponentProps } from '@dxos/app-framework/react';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
 import { type Blueprint } from '@dxos/blueprints';
 import { Obj } from '@dxos/echo';
-import { Toolbar } from '@dxos/react-ui';
+import { Layout, Toolbar } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
-import { StackItem } from '@dxos/react-ui-stack';
 
 import { TemplateEditor } from './TemplateEditor';
 
 export type BlueprintArticleProps = SurfaceComponentProps<Blueprint.Blueprint>;
 
-export const BlueprintArticle = ({ subject }: BlueprintArticleProps) => {
+export const BlueprintArticle = ({ role, subject }: BlueprintArticleProps) => {
   const { hasAttention } = useAttention(Obj.getDXN(subject).toString());
 
   return (
-    <StackItem.Content toolbar>
+    <Layout.Main role={role} toolbar>
       <Toolbar.Root disabled={!hasAttention} />
       <TemplateEditor id={subject.id} template={subject.instructions} classNames='container-max-width' />
-    </StackItem.Content>
+    </Layout.Main>
   );
 };
 

package/src/components/Chat/Chat.tsx

@@ -10,23 +10,23 @@ import * as Array from 'effect/Array';
 import * as Option from 'effect/Option';
 import React, { type PropsWithChildren, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
+import { type Chat as ChatModule } from '@dxos/assistant-toolkit';
 import { Event } from '@dxos/async';
-import { Obj } from '@dxos/echo';
+import { type Database, Filter, Obj } from '@dxos/echo';
 import { useVoiceInput } from '@dxos/plugin-transcription';
-import { type Space, getSpace, 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 { mx } from '@dxos/react-ui-theme';
 import { Message } from '@dxos/types';
+import { mx } from '@dxos/ui-theme';
 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,
@@ -48,8 +48,8 @@ import { type ChatEvent } from './events';
 type ChatContextValue = {
   debug?: boolean;
   event: Event<ChatEvent>;
-  space?: Space;
-  chat?: Assistant.Chat;
+  db?: Database.Database;
+  chat?: ChatModule.Chat;
   messages: Message.Message[];
   processor: AiChatProcessor;
 };
@@ -61,7 +61,7 @@ export const [ChatContextProvider, useChatContext] = createContext<ChatContextVa
 //
 
 type ChatRootProps = PropsWithChildren<
-  Pick<ChatContextValue, 'space' | 'chat' | 'processor'> & {
+  Pick<ChatContextValue, 'db' | 'chat' | 'processor'> & {
     onEvent?: (event: ChatEvent) => void;
   }
 >;
@@ -73,11 +73,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>(), []);
@@ -86,6 +85,24 @@ const ChatRoot = ({ children, chat, processor, onEvent, ...props }: ChatRootProp
       switch (ev.type) {
         case 'toggle-debug': {
           setDebug((current) => !current);
+          // 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;
         }
 
@@ -120,13 +137,13 @@ const ChatRoot = ({ children, chat, processor, onEvent, ...props }: ChatRootProp
     });
   }, [event, processor, streaming, onEvent]);
 
-  const space = props.space ?? getSpace(chat);
+  const db = props.db ?? (chat && Obj.getDatabase(chat));
 
   return (
     <ChatContextProvider
       debug={debug}
       event={event}
-      space={space}
+      db={db}
       chat={chat}
       messages={messages}
       processor={processor}
@@ -143,6 +160,8 @@ ChatRoot.displayName = 'Chat.Root';
 // Viewport
 //
 
+const CHAT_VIEWPORT_NAME = 'Chat.Viewport';
+
 type ChatViewportProps = ThemedClassName<PropsWithChildren>;
 
 const ChatViewport = ({ classNames, children }: ChatViewportProps) => {
@@ -153,10 +172,71 @@ const ChatViewport = ({ classNames, children }: ChatViewportProps) => {
   );
 };
 
+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(CHAT_THREAD_NAME);
+  const identity = useIdentity();
+  const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
+
+  const controllerRef = useRef<MarkdownStreamController | null>(null);
+  useEffect(() => {
+    return event.on((event) => {
+      switch (event.type) {
+        case 'submit':
+        case 'scroll-to-bottom':
+          controllerRef.current?.scrollToBottom();
+          break;
+        case 'nav-previous':
+          controllerRef.current?.navigatePrevious();
+          break;
+        case 'nav-next':
+          controllerRef.current?.navigateNext();
+          break;
+      }
+    });
+  }, [event]);
+
+  const handleEvent = useCallback<NonNullable<NaturalChatThreadProps['onEvent']>>(
+    (ev) => {
+      event.emit(ev);
+    },
+    [event],
+  );
+
+  if (!identity) {
+    return null;
+  }
+
+  return (
+    <NaturalChatThread
+      {...props}
+      identity={identity}
+      messages={messages}
+      error={error}
+      debug={debug}
+      onEvent={handleEvent}
+      ref={controllerRef}
+    />
+  );
+};
+
+ChatThread.displayName = CHAT_THREAD_NAME;
+
 //
 // Prompt
 //
 
+const CHAT_PROMPT_NAME = 'Chat.Prompt';
+
 type ChatPromptProps = ThemedClassName<
   {
     outline?: boolean;
@@ -183,7 +263,7 @@ const ChatPrompt = ({
   onOnlineChange,
 }: ChatPromptProps) => {
   const { t } = useTranslation(meta.id);
-  const { space, 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);
@@ -301,10 +381,10 @@ const ChatPrompt = ({
         />
       </div>
 
-      {space && settings && (
+      {db && settings && (
         <div role='none' className='flex items-center overflow-hidden'>
           <ChatOptions
-            space={space}
+            db={db}
             blueprintRegistry={processor.blueprintRegistry}
             context={processor.context}
             preset={preset}
@@ -313,7 +393,7 @@ const ChatPrompt = ({
           />
 
           <div role='none' className='flex grow overflow-x-auto scrollbar-none'>
-            <ChatReferences space={space} context={processor.context} />
+            <ChatReferences db={db} context={processor.context} />
           </div>
 
           <ChatActions
@@ -337,71 +417,18 @@ const ChatPrompt = ({
   );
 };
 
-ChatPrompt.displayName = 'Chat.Prompt';
-
-//
-// Thread
-//
-
-type ChatThreadProps = Omit<NaturalChatThreadProps, 'identity' | 'messages' | 'tools'>;
-
-const ChatThread = (props: ChatThreadProps) => {
-  const { debug, event, messages, processor } = useChatContext(ChatThread.displayName);
-  const identity = useIdentity();
-  const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
-
-  const controllerRef = useRef<MarkdownStreamController | null>(null);
-  useEffect(() => {
-    return event.on((event) => {
-      switch (event.type) {
-        case 'submit':
-        case 'scroll-to-bottom':
-          controllerRef.current?.scrollToBottom();
-          break;
-        case 'nav-previous':
-          controllerRef.current?.navigatePrevious();
-          break;
-        case 'nav-next':
-          controllerRef.current?.navigateNext();
-          break;
-      }
-    });
-  }, [event]);
-
-  const handleEvent = useCallback<NonNullable<NaturalChatThreadProps['onEvent']>>(
-    (ev) => {
-      event.emit(ev);
-    },
-    [event],
-  );
-
-  if (!identity) {
-    return null;
-  }
-
-  return (
-    <NaturalChatThread
-      {...props}
-      identity={identity}
-      messages={messages}
-      error={error}
-      debug={debug}
-      onEvent={handleEvent}
-      ref={controllerRef}
-    />
-  );
-};
-
-ChatThread.displayName = 'Chat.Thread';
+ChatPrompt.displayName = CHAT_PROMPT_NAME;
 
 //
 // Toolbar
 //
 
-type ChatToolbarProps = ThemedClassName<{ companionTo?: Obj.Any }>;
+const CHAT_TOOLBAR_NAME = 'Chat.Toolbar';
+
+type ChatToolbarProps = ThemedClassName<{ companionTo?: Obj.Unknown }>;
 
 const ChatToolbar = ({ classNames, companionTo }: ChatToolbarProps) => {
-  const { chat } = useChatContext(ChatToolbar.displayName);
+  const { chat } = useChatContext(CHAT_TOOLBAR_NAME);
   const menu = useChatToolbarActions({ chat, companionTo });
 
   return (
@@ -414,7 +441,7 @@ const ChatToolbar = ({ classNames, companionTo }: ChatToolbarProps) => {
   );
 };
 
-ChatToolbar.displayName = 'Chat.Toolbar';
+ChatToolbar.displayName = CHAT_TOOLBAR_NAME;
 
 //
 // Chat
@@ -423,8 +450,8 @@ ChatToolbar.displayName = 'Chat.Toolbar';
 export const Chat = {
   Root: ChatRoot,
   Viewport: ChatViewport,
-  Prompt: ChatPrompt,
   Thread: ChatThread,
+  Prompt: ChatPrompt,
   Toolbar: ChatToolbar,
 };
 

package/src/components/Chat/events.ts

@@ -31,7 +31,7 @@ export type ChatEvent =
     }
   | {
       type: 'add';
-      object: Obj.Any;
+      object: Obj.Unknown;
     }
   //
   // UX