@dxos/plugin-assistant 0.8.4-main.406dc2a → 0.8.4-main.548089c

package/src/capabilities/react-surface.tsx

@@ -5,7 +5,7 @@
 import React from 'react';
 
 import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/blueprints';
+import { Blueprint, Prompt } from '@dxos/blueprints';
 import { getSpace } from '@dxos/client/echo';
 import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
@@ -15,12 +15,11 @@ import { StackItem } from '@dxos/react-ui-stack';
 
 import {
   AssistantSettings,
-  BlueprintContainer,
+  BlueprintArticle,
   ChatCompanion,
   ChatContainer,
   ChatDialog,
-  PromptSettings,
-  SequenceContainer,
+  PromptArticle,
 } from '../components';
 import { ASSISTANT_DIALOG, meta } from '../meta';
 import { Assistant } from '../types';
@@ -41,6 +40,7 @@ export default () =>
         Obj.instanceOf(Assistant.Chat, data.subject) && data.variant !== 'assistant-chat',
       component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
     }),
+    // TODO(wittjosiah): This is flashing when chat changes.
     createSurface({
       id: `${meta.id}/companion-chat`,
       role: 'article',
@@ -50,22 +50,18 @@ export default () =>
       component: ({ data, role }) => <ChatCompanion role={role} data={data} />,
     }),
     createSurface({
-      id: `${meta.id}/sequence`,
-      role: 'article',
-      filter: (data): data is { subject: Sequence } => Obj.instanceOf(Sequence, data.subject),
-      component: ({ data }) => <SequenceContainer sequence={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/companion-logs`,
+      id: `${meta.id}/companion-invocations`,
       role: 'article',
       filter: (data): data is { companionTo: Sequence } =>
-        Obj.instanceOf(Sequence, data.companionTo) && data.subject === 'logs',
-      // eslint-disable-next-line unused-imports/no-unused-vars
-      component: ({ data, role }) => {
+        (Obj.instanceOf(Sequence, data.companionTo) || Obj.instanceOf(Prompt.Prompt, data.companionTo)) &&
+        data.subject === 'invocations',
+      component: ({ data }) => {
         const space = getSpace(data.companionTo);
+        // TODO(wittjosiah): Support invocation filtering for prompts.
+        const target = Obj.instanceOf(Prompt.Prompt, data.companionTo) ? undefined : data.companionTo;
         return (
           <StackItem.Content>
-            <InvocationTraceContainer space={space} target={data.companionTo} detailAxis='block' />
+            <InvocationTraceContainer space={space} target={target} detailAxis='block' />
           </StackItem.Content>
         );
       },
@@ -74,13 +70,13 @@ export default () =>
       id: `${meta.id}/blueprint`,
       role: 'article',
       filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
-      component: ({ data }) => <BlueprintContainer blueprint={data.subject} />,
+      component: ({ data }) => <BlueprintArticle object={data.subject} />,
     }),
     createSurface({
-      id: `${meta.id}/prompt-settings`,
-      role: 'object-settings',
-      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
-      component: ({ data }) => <PromptSettings template={data.subject.instructions} />,
+      id: `${meta.id}/prompt`,
+      role: 'article',
+      filter: (data): data is { subject: Prompt.Prompt } => Obj.instanceOf(Prompt.Prompt, data.subject),
+      component: ({ data }) => <PromptArticle object={data.subject} />,
     }),
     createSurface({
       id: ASSISTANT_DIALOG,

package/src/capabilities/state.ts

@@ -16,5 +16,7 @@ export default () => {
     currentChat: {},
   });
 
+  state.prop({ key: 'currentChat', type: LocalStorageStore.json<Record<string, string | undefined>>() });
+
   return contributes(AssistantCapabilities.State, state.values, () => state.close());
 };

package/src/capabilities/toolkit.ts

@@ -2,167 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
+import * as Layer from 'effect/Layer';
 
-import { Capabilities, type Capability, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { AiContextService, ArtifactId } from '@dxos/assistant';
-import { WebSearchToolkit } from '@dxos/assistant-testing';
-import { Filter, Obj, Ref, SchemaNotFoundError, Type } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { invariant } from '@dxos/invariant';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { SpaceCapabilities, getActiveSpace } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { DataType } from '@dxos/schema';
-import { trim } from '@dxos/util';
+import { Capabilities, type Capability, type PluginContext, contributes } from '@dxos/app-framework';
+import { GenericToolkit } from '@dxos/assistant';
+import { AssistantToolkit, SystemToolkit, WebSearchToolkit } from '@dxos/assistant-toolkit';
 
-// TODO(burdon): Reconcile with functions (currently reuses plugin framework intents).
-class AssistantToolkit extends Toolkit.make(
-  Tool.make('add-to-context', {
-    description: trim`
-      Adds the object to the chat context.
-    `,
-    parameters: {
-      id: ArtifactId.annotations({
-        description: 'The ID of the document to read.',
-      }),
-    },
-    success: Schema.Void,
-    failure: Schema.Never,
-    dependencies: [AiContextService, DatabaseService],
-  }),
+export default (_context: PluginContext): Capability<any>[] => [
+  contributes(Capabilities.Toolkit, GenericToolkit.make(AssistantToolkit.AssistantToolkit, AssistantToolkit.layer())),
 
-  Tool.make('get-schemas', {
-    description: trim`
-      Retrieves schemas definitions.
-    `,
-    parameters: {
-      // TODO(wittjosiah): Remove this once parameter-less tools are fixed.
-      limit: Schema.Number,
-    },
-    // TODO(dmaretskyi): Effect returns ({ result, encodedResult })
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  Tool.make('add-schema', {
-    description: trim`
-      Adds a schema to the space.
-      The name will be used when displayed to the user.
-      The typename must be in the format of "example.com/type/Type".
-    `,
-    parameters: {
-      name: Schema.String,
-      typename: Schema.String,
-      jsonSchema: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  Tool.make('create-record', {
-    description: trim`
-      Creates a new record and adds it to the current space.
-      Get the schema from the get-schemas tool and ensure that the data matches the corresponding schema.
-      Note that only record schemas are supported.
-    `,
-    parameters: {
-      typename: Schema.String,
-      data: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-) {
-  static layer = (context: PluginContext) =>
-    AssistantToolkit.toLayer({
-      'add-to-context': Effect.fnUntraced(function* ({ id }) {
-        const { binder } = yield* AiContextService;
-        const { db } = yield* DatabaseService;
-        const ref = Ref.fromDXN(ArtifactId.toDXN(id, db.spaceId));
-        yield* Effect.promise(() =>
-          binder.bind({
-            blueprints: [],
-            objects: [ref],
-          }),
-        );
-      }),
-
-      'get-schemas': () => {
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const whitelist = context
-            .getCapabilities(ClientCapabilities.SchemaWhiteList)
-            .flat()
-            .map((schema) => ({
-              typename: Type.getTypename(schema),
-              jsonSchema: Type.toJsonSchema(schema),
-              kind: 'record',
-            }));
-
-          // TODO(burdon): Why ObjectForm (bad name for data capability; UI term)?
-          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
-            typename: Type.getTypename(form.objectSchema),
-            jsonSchema: Type.toJsonSchema(form.objectSchema),
-            kind: 'item',
-          }));
-
-          const schemas = [...whitelist, ...forms];
-          if (space) {
-            const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-            schemas.push(
-              ...objects.map((object) => ({
-                typename: object.typename,
-                jsonSchema: object.jsonSchema,
-                kind: 'record',
-              })),
-            );
-          }
-
-          return schemas;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)));
-      },
-
-      'add-schema': ({ name, typename, jsonSchema }) => {
-        return Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const space = getActiveSpace(context);
-          invariant(space, 'No active space');
-
-          const schema = Type.toEffectSchema(jsonSchema).pipe(Type.Obj({ typename, version: '0.1.0' }));
-          yield* dispatch(createIntent(SpaceAction.AddSchema, { space, name, typename, schema }));
-        }).pipe(Effect.orDie);
-      },
-
-      'create-record': ({ typename, data }) => {
-        const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const schemas = context.getCapabilities(ClientCapabilities.SchemaWhiteList).flat();
-          const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-          schemas.push(...objects.map((object) => Type.toEffectSchema(object.jsonSchema)));
-          const schema = schemas.find((schema) => Type.getTypename(schema) === typename);
-          if (!schema) {
-            throw new SchemaNotFoundError(typename);
-          }
-
-          const object = Obj.make(schema, data);
-          yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-          return object;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
-      },
-    });
-}
-
-export default (context: PluginContext): Capability<any>[] => [
-  contributes(Capabilities.Toolkit, AssistantToolkit),
-  contributes(Capabilities.ToolkitHandler, AssistantToolkit.layer(context)),
-  contributes(Capabilities.Toolkit, WebSearchToolkit),
+  // TODO(burdon): How to manage dependencies across blueprints.
+  contributes(Capabilities.Toolkit, GenericToolkit.make(SystemToolkit.SystemToolkit, SystemToolkit.layer())),
+  contributes(Capabilities.Toolkit, GenericToolkit.make(WebSearchToolkit, Layer.empty)),
 ];

package/src/components/BlueprintArticle.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-framework/react';
+import { type Blueprint } from '@dxos/blueprints';
+import { Obj } from '@dxos/echo';
+import { 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 = ({ object }: BlueprintArticleProps) => {
+  const { hasAttention } = useAttention(Obj.getDXN(object).toString());
+
+  return (
+    <StackItem.Content toolbar>
+      <Toolbar.Root disabled={!hasAttention} />
+      <TemplateEditor id={object.id} template={object.instructions} classNames='container-max-width' />
+    </StackItem.Content>
+  );
+};
+
+export default BlueprintArticle;

package/src/components/Chat/Chat.tsx

@@ -4,7 +4,7 @@
 
 import { type Extension, Prec } from '@codemirror/state';
 import { keymap } from '@codemirror/view';
-import { useRxValue } from '@effect-rx/rx-react';
+import { useAtomValue } from '@effect-atom/atom-react';
 import { createContext } from '@radix-ui/react-context';
 import * as Array from 'effect/Array';
 import * as Option from 'effect/Option';
@@ -17,11 +17,13 @@ import { type Space, getSpace, useQueue } 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, references } 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 { DataType } from '@dxos/schema';
+import { Message } from '@dxos/types';
 import { isTruthy } from '@dxos/util';
 
-import { useReferencesProvider } from '../../hooks';
+import { useChatToolbarActions, useReferencesProvider } from '../../hooks';
 import { meta } from '../../meta';
 import { type AiChatProcessor } from '../../processor';
 import { type Assistant } from '../../types';
@@ -33,11 +35,7 @@ import {
   ChatReferences,
   ChatStatusIndicator,
 } from '../ChatPrompt';
-import {
-  type ChatThreadController,
-  ChatThread as NaturalChatThread,
-  type ChatThreadProps as NaturalChatThreadProps,
-} from '../ChatThread';
+import { ChatThread as NaturalChatThread, type ChatThreadProps as NaturalChatThreadProps } from '../ChatThread';
 
 import { type ChatEvent } from './events';
 
@@ -50,9 +48,9 @@ import { type ChatEvent } from './events';
 type ChatContextValue = {
   debug?: boolean;
   event: Event<ChatEvent>;
-  space: Space;
-  chat: Assistant.Chat;
-  messages: DataType.Message[];
+  space?: Space;
+  chat?: Assistant.Chat;
+  messages: Message.Message[];
   processor: AiChatProcessor;
 };
 
@@ -62,27 +60,23 @@ export const [ChatContextProvider, useChatContext] = createContext<ChatContextVa
 // Root
 //
 
-type ChatRootProps = ThemedClassName<
-  PropsWithChildren<
-    Pick<ChatContextValue, 'chat' | 'processor'> & {
-      onEvent?: (event: ChatEvent) => void;
-    }
-  >
+type ChatRootProps = PropsWithChildren<
+  Pick<ChatContextValue, 'space' | 'chat' | 'processor'> & {
+    onEvent?: (event: ChatEvent) => void;
+  }
 >;
 
-const ChatRoot = ({ classNames, children, chat, processor, onEvent, ...props }: ChatRootProps) => {
+const ChatRoot = ({ children, chat, processor, onEvent, ...props }: ChatRootProps) => {
   const [debug, setDebug] = useState(false);
-  const space = getSpace(chat);
-
-  // Messages.
-  const queue = useQueue<DataType.Message>(chat?.queue.dxn);
-  const pending = useRxValue(processor.messages);
-  const streaming = useRxValue(processor.streaming);
+  const pending = useAtomValue(processor.messages);
+  const streaming = useAtomValue(processor.streaming);
   const lastPrompt = useRef<string | undefined>(undefined);
 
+  // Messages.
+  const queue = useQueue<Message.Message>(chat?.queue.dxn);
   const messages = useMemo(() => {
-    const queueMessages = queue?.objects?.filter(Obj.instanceOf(DataType.Message)) ?? [];
-    return Array.dedupeWith([...queueMessages, ...pending], (a, b) => a.id === b.id);
+    const queueMessages = queue?.objects?.filter(Obj.instanceOf(Message.Message)) ?? [];
+    return Array.dedupeWith([...queueMessages, ...pending], ({ id: a }, { id: b }) => a === b);
   }, [queue?.objects, pending]);
 
   // Events.
@@ -120,37 +114,45 @@ const ChatRoot = ({ classNames, children, chat, processor, onEvent, ...props }:
           }
           break;
         }
-
-        default: {
-          onEvent?.(ev);
-        }
       }
+
+      onEvent?.(ev);
     });
   }, [event, processor, streaming, onEvent]);
 
-  if (!space) {
-    return null;
-  }
+  const space = props.space ?? getSpace(chat);
 
   return (
     <ChatContextProvider
       debug={debug}
       event={event}
-      chat={chat}
       space={space}
+      chat={chat}
       messages={messages}
       processor={processor}
       {...props}
     >
-      <div role='none' className={mx('flex flex-col bs-full is-full', classNames)}>
-        {children}
-      </div>
+      {children}
     </ChatContextProvider>
   );
 };
 
 ChatRoot.displayName = 'Chat.Root';
 
+//
+// Viewport
+//
+
+type ChatViewportProps = ThemedClassName<PropsWithChildren>;
+
+const ChatViewport = ({ classNames, children }: ChatViewportProps) => {
+  return (
+    <div role='none' className={mx('flex flex-col bs-full is-full', classNames)}>
+      {children}
+    </div>
+  );
+};
+
 //
 // Prompt
 //
@@ -181,11 +183,11 @@ const ChatPrompt = ({
   onOnlineChange,
 }: ChatPromptProps) => {
   const { t } = useTranslation(meta.id);
-  const { space, event, processor } = useChatContext(ChatPrompt.displayName);
+  const { space, processor, event } = useChatContext(ChatPrompt.displayName);
 
-  const error = useRxValue(processor.error).pipe(Option.getOrUndefined);
-  const streaming = useRxValue(processor.streaming);
-  const active = useRxValue(processor.active);
+  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);
@@ -227,29 +229,49 @@ const ChatPrompt = ({
         keymap.of(
           [
             {
-              key: 'cmd-d',
+              key: 'Mod-d',
               preventDefault: true,
               run: () => {
                 event.emit({ type: 'toggle-debug' });
                 return true;
               },
             },
-            expandable && {
-              key: 'cmd-ArrowUp',
+            {
+              key: 'Mod-ArrowUp',
               preventDefault: true,
               run: () => {
-                event.emit({ type: 'thread-open' });
+                event.emit({ type: 'nav-previous' });
                 return true;
               },
             },
-            expandable && {
-              key: 'cmd-ArrowDown',
+            {
+              key: 'Mod-ArrowDown',
               preventDefault: true,
               run: () => {
-                event.emit({ type: 'thread-close' });
+                event.emit({ type: 'nav-next' });
                 return true;
               },
             },
+            ...(expandable
+              ? [
+                  {
+                    key: 'Shift-Mod-ArrowUp',
+                    preventDefault: true,
+                    run: () => {
+                      event.emit({ type: 'thread-open' });
+                      return true;
+                    },
+                  },
+                  {
+                    key: 'Shift-Mod-ArrowDown',
+                    preventDefault: true,
+                    run: () => {
+                      event.emit({ type: 'thread-close' });
+                      return true;
+                    },
+                  },
+                ]
+              : []),
           ].filter(isTruthy),
         ),
       ),
@@ -298,8 +320,8 @@ const ChatPrompt = ({
         />
       </div>
 
-      {settings && (
-        <div role='none' className='flex pbs-2 items-center'>
+      {space && settings && (
+        <div role='none' className='flex pbs-2 items-center overflow-hidden'>
           <ChatOptions
             space={space}
             blueprintRegistry={processor.blueprintRegistry}
@@ -309,7 +331,7 @@ const ChatPrompt = ({
             onPresetChange={onPresetChange}
           />
 
-          <div role='none' className='pli-cardSpacingChrome grow'>
+          <div role='none' className='flex grow overflow-x-auto scrollbar-none'>
             <ChatReferences space={space} context={processor.context} />
           </div>
 
@@ -320,10 +342,11 @@ const ChatPrompt = ({
             processing={streaming}
             onEvent={handleEvent}
           >
+            {/* TODO(burdon): Move switch into dialog. */}
             {online !== undefined && (
               <Input.Root>
                 <Input.Label srOnly>{t('online switch label')}</Input.Label>
-                <Input.Switch classNames='mis-2 mie-2' checked={online} onCheckedChange={onOnlineChange} />
+                <Input.Switch classNames='mli-2' checked={online} onCheckedChange={onOnlineChange} />
               </Input.Root>
             )}
           </ChatActions>
@@ -342,17 +365,23 @@ ChatPrompt.displayName = 'Chat.Prompt';
 type ChatThreadProps = Omit<NaturalChatThreadProps, 'identity' | 'messages' | 'tools'>;
 
 const ChatThread = (props: ChatThreadProps) => {
-  const { event, messages, processor } = useChatContext(ChatThread.displayName);
+  const { debug, event, messages, processor } = useChatContext(ChatThread.displayName);
   const identity = useIdentity();
-  const error = useRxValue(processor.error).pipe(Option.getOrUndefined);
+  const error = useAtomValue(processor.error).pipe(Option.getOrUndefined);
 
-  const scrollerRef = useRef<ChatThreadController | null>(null);
+  const controllerRef = useRef<MarkdownStreamController | null>(null);
   useEffect(() => {
     return event.on((event) => {
       switch (event.type) {
         case 'submit':
         case 'scroll-to-bottom':
-          scrollerRef.current?.scrollToBottom();
+          controllerRef.current?.scrollToBottom();
+          break;
+        case 'nav-previous':
+          controllerRef.current?.navigatePrevious();
+          break;
+        case 'nav-next':
+          controllerRef.current?.navigateNext();
           break;
       }
     });
@@ -372,25 +401,50 @@ const ChatThread = (props: ChatThreadProps) => {
   return (
     <NaturalChatThread
       {...props}
-      ref={scrollerRef}
       identity={identity}
       messages={messages}
       error={error}
+      debug={debug}
       onEvent={handleEvent}
+      ref={controllerRef}
     />
   );
 };
 
 ChatThread.displayName = 'Chat.Thread';
 
+//
+// Toolbar
+//
+
+type ChatToolbarProps = ThemedClassName<{ companionTo?: Obj.Any }>;
+
+const ChatToolbar = ({ classNames, companionTo }: ChatToolbarProps) => {
+  const { chat } = useChatContext(ChatToolbar.displayName);
+  const menu = useChatToolbarActions({ chat, companionTo });
+
+  return (
+    <MenuProvider
+      {...menu}
+      attendableId={companionTo ? Obj.getDXN(companionTo).toString() : chat ? Obj.getDXN(chat).toString() : ''}
+    >
+      <ToolbarMenu classNames={classNames} textBlockWidth />
+    </MenuProvider>
+  );
+};
+
+ChatToolbar.displayName = 'Chat.Toolbar';
+
 //
 // Chat
 //
 
 export const Chat = {
   Root: ChatRoot,
+  Viewport: ChatViewport,
   Prompt: ChatPrompt,
   Thread: ChatThread,
+  Toolbar: ChatToolbar,
 };
 
-export type { ChatRootProps, ChatThreadProps, ChatPromptProps, ChatEvent };
+export type { ChatRootProps, ChatViewportProps, ChatThreadProps, ChatPromptProps, ChatToolbarProps, ChatEvent };

package/src/components/Chat/events.ts

@@ -43,6 +43,12 @@ export type ChatEvent =
   | {
       type: 'scroll-to-bottom';
     }
+  | {
+      type: 'nav-previous';
+    }
+  | {
+      type: 'nav-next';
+    }
   | {
       type: 'thread-open';
     }