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

package/src/capabilities/intent-resolver.ts

@@ -4,31 +4,38 @@
 
 import { Effect } from 'effect';
 
-import { Capabilities, contributes, createIntent, createResolver, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
+import { Blueprint, Template } from '@dxos/blueprints';
 import { Sequence } from '@dxos/conductor';
 import { Key, Obj, Ref } from '@dxos/echo';
 import { CollectionAction } from '@dxos/plugin-space/types';
 
-import { Assistant } from '../types';
+import { Assistant, AssistantAction } from '../types';
 
 export default (context: PluginContext) => [
   contributes(Capabilities.IntentResolver, [
     createResolver({
-      intent: Assistant.OnSpaceCreated,
+      intent: AssistantAction.OnSpaceCreated,
       resolve: ({ space, rootCollection }) =>
         Effect.gen(function* () {
           const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const { object: collection } = yield* dispatch(
+          const { object: chatCollection } = yield* dispatch(
             createIntent(CollectionAction.CreateQueryCollection, { typename: Assistant.Chat.typename }),
           );
-          rootCollection.objects.push(Ref.make(collection));
-
-          const { object: chat } = yield* dispatch(createIntent(Assistant.CreateChat, { space }));
+          const { object: blueprintCollection } = yield* dispatch(
+            createIntent(CollectionAction.CreateQueryCollection, { typename: Blueprint.Blueprint.typename }),
+          );
+          rootCollection.objects.push(Ref.make(chatCollection), Ref.make(blueprintCollection));
+          const { object: chat } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
           space.db.add(chat);
+
+          // TODO(wittjosiah): Create default blueprint.
+          // const { object: blueprint } = yield* dispatch(createIntent(AssistantAction.CreateBlueprint, { ... }));
+          // space.db.add(blueprint);
         }),
     }),
     createResolver({
-      intent: Assistant.CreateChat,
+      intent: AssistantAction.CreateChat,
       resolve: ({ space, name }) => ({
         data: {
           object: Obj.make(Assistant.Chat, {
@@ -39,7 +46,15 @@ export default (context: PluginContext) => [
       }),
     }),
     createResolver({
-      intent: Assistant.CreateSequence,
+      intent: AssistantAction.CreateBlueprint,
+      resolve: ({ key, name, description }) => ({
+        data: {
+          object: Blueprint.make({ key, name, description, instructions: Template.make({ source: '' }) }),
+        },
+      }),
+    }),
+    createResolver({
+      intent: AssistantAction.CreateSequence,
       resolve: ({ name }) => ({
         data: {
           object: Obj.make(Sequence, {

package/src/capabilities/react-surface.tsx

@@ -3,28 +3,29 @@
 //
 
 import { Effect } from 'effect';
-import React, { useEffect, useMemo } from 'react';
+import React, { useCallback, useEffect } from 'react';
 
 import { Capabilities, contributes, createIntent, createSurface, useIntentDispatcher } from '@dxos/app-framework';
-import { Template } from '@dxos/blueprints';
-import { fullyQualifiedId, getSpace, getTypename } from '@dxos/client/echo';
+import { Blueprint } from '@dxos/blueprints';
+import { getSpace } from '@dxos/client/echo';
 import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
-import { Filter, type Key, Obj, Query } from '@dxos/echo';
+import { Filter, Obj, Query, Ref } from '@dxos/echo';
 import { SettingsStore } from '@dxos/local-storage';
 import { SpaceAction } from '@dxos/plugin-space/types';
 import { StackItem } from '@dxos/react-ui-stack';
 
 import {
   AssistantSettings,
+  BlueprintContainer,
   ChatContainer,
   ChatDialog,
   PromptSettings,
   SequenceContainer,
-  TemplateContainer,
 } from '../components';
-import { meta, ASSISTANT_DIALOG } from '../meta';
-import { Assistant } from '../types';
+import { type AiChatProcessor } from '../hooks';
+import { ASSISTANT_DIALOG, meta } from '../meta';
+import { Assistant, AssistantAction } from '../types';
 
 export default () =>
   contributes(Capabilities.ReactSurface, [
@@ -50,15 +51,8 @@ export default () =>
         (Obj.instanceOf(Assistant.Chat, data.subject) || data.subject === 'assistant-chat'),
       component: ({ data, role }) => {
         const { dispatch } = useIntentDispatcher();
-        const associatedArtifact = useMemo(
-          () => ({
-            id: fullyQualifiedId(data.companionTo),
-            typename: getTypename(data.companionTo) ?? 'unknown',
-            spaceId: (getSpace(data.companionTo)?.id ?? 'unknown') as Key.SpaceId,
-          }),
-          [data.companionTo],
-        );
 
+        // Initialize companion chat if it doesn't exist.
         // TODO(wittjosiah): Factor out to container.
         useEffect(() => {
           const timeout = setTimeout(async () => {
@@ -72,7 +66,7 @@ export default () =>
               }
 
               const program = Effect.gen(function* () {
-                const { object } = yield* dispatch(createIntent(Assistant.CreateChat, { space }));
+                const { object } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
                 yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
                 yield* dispatch(
                   createIntent(SpaceAction.AddRelation, {
@@ -83,6 +77,7 @@ export default () =>
                   }),
                 );
               });
+
               void Effect.runPromise(program);
             }
           });
@@ -90,11 +85,23 @@ export default () =>
           return () => clearTimeout(timeout);
         }, [data.subject]);
 
+        // TODO(wittjosiah): Factor out to container.
+        const handleProcessorReady = useCallback(
+          (processor: AiChatProcessor) => {
+            if (Obj.instanceOf(Blueprint.Blueprint, data.companionTo)) {
+              void processor.context.bind({ blueprints: [Ref.make(data.companionTo)] });
+            } else {
+              void processor.context.bind({ objects: [Ref.make(data.companionTo)] });
+            }
+          },
+          [data.companionTo],
+        );
+
         if (data.subject === 'assistant-chat') {
           return null;
         }
 
-        return <ChatContainer role={role} chat={data.subject} artifact={associatedArtifact} />;
+        return <ChatContainer role={role} chat={data.subject} onProcessorReady={handleProcessorReady} />;
       },
     }),
     createSurface({
@@ -118,16 +125,16 @@ export default () =>
       },
     }),
     createSurface({
-      id: `${meta.id}/template`,
+      id: `${meta.id}/blueprint`,
       role: 'article',
-      filter: (data): data is { subject: Template.Template } => Obj.instanceOf(Template.Template, data.subject),
-      component: ({ data }) => <TemplateContainer template={data.subject} />,
+      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
+      component: ({ data }) => <BlueprintContainer blueprint={data.subject} />,
     }),
     createSurface({
       id: `${meta.id}/prompt-settings`,
       role: 'object-settings',
-      filter: (data): data is { subject: Template.Template } => Obj.instanceOf(Template.Template, data.subject),
-      component: ({ data }) => <PromptSettings template={data.subject} />,
+      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
+      component: ({ data }) => <PromptSettings template={data.subject.instructions} />,
     }),
     createSurface({
       id: ASSISTANT_DIALOG,

package/src/capabilities/toolkit.ts

@@ -0,0 +1,106 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { AiTool, AiToolkit } from '@effect/ai';
+import { Effect, Schema } from 'effect';
+
+import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { Filter, Obj, Type } from '@dxos/echo';
+import { DatabaseService } from '@dxos/functions';
+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';
+
+class SchemaToolkit extends AiToolkit.make(
+  AiTool.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,
+  }),
+  AiTool.make('create-record', {
+    description: trim`
+      Creates a new record.
+      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) =>
+    SchemaToolkit.toLayer({
+      //
+      'get-schemas': () => {
+        const space = getActiveSpace(context);
+        const service = space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable;
+        return Effect.gen(function* () {
+          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
+            typename: Type.getTypename(form.objectSchema),
+            jsonSchema: Type.toJsonSchema(form.objectSchema),
+            kind: 'item',
+          }));
+          const allowed = context
+            .getCapabilities(ClientCapabilities.SchemaWhiteList)
+            .flat()
+            .map((schema) => ({
+              typename: Type.getTypename(schema),
+              jsonSchema: Type.toJsonSchema(schema),
+              kind: 'record',
+            }));
+          const schemas = [...forms, ...allowed];
+          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.map((schema) => schema.typename);
+        }).pipe(Effect.provide(service));
+      },
+
+      //
+      'create-record': ({ typename, data }) => {
+        const space = getActiveSpace(context);
+        const service = space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable;
+        console.log('create-record', { typename, data, space });
+        return Effect.gen(function* () {
+          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+          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 Error(`Schema not found for ${typename}`);
+          }
+
+          const object = Obj.make(schema, data);
+          yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space!, hidden: true }));
+          return object;
+        }).pipe(Effect.provide(service), Effect.orDie);
+      },
+    });
+}
+
+export default (context: PluginContext) => [
+  contributes(Capabilities.Toolkit, SchemaToolkit),
+  contributes(Capabilities.ToolkitHandler, SchemaToolkit.layer(context)),
+];

package/src/components/AssistantSettings/AssistantSettings.tsx

@@ -9,7 +9,7 @@ import { Input, Select, useTranslation } from '@dxos/react-ui';
 import { DeprecatedFormContainer, DeprecatedFormInput } from '@dxos/react-ui-form';
 
 import { meta } from '../../meta';
-import { LLM_PROVIDERS, type Assistant } from '../../types';
+import { type Assistant, LLM_PROVIDERS } from '../../types';
 
 // TODO(burdon): Factor out default Selector.
 const DEFAULT_VALUE = '__default';

package/src/components/BlueprintContainer.tsx

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type Blueprint } from '@dxos/blueprints';
+import { StackItem } from '@dxos/react-ui-stack';
+
+import { TemplateEditor } from './TemplateEditor';
+
+export type BlueprintContainerProps = {
+  blueprint: Blueprint.Blueprint;
+};
+
+export const BlueprintContainer = ({ blueprint }: BlueprintContainerProps) => {
+  return (
+    <StackItem.Content classNames='container-max-width'>
+      <TemplateEditor id={blueprint.id} template={blueprint.instructions} />
+    </StackItem.Content>
+  );
+};
+
+export default BlueprintContainer;

package/src/components/Chat/Chat.tsx

@@ -4,32 +4,31 @@
 
 import { type Extension, Prec } from '@codemirror/state';
 import { keymap } from '@codemirror/view';
+import { Result, useRxValue } from '@effect-rx/rx-react';
 import { createContext } from '@radix-ui/react-context';
-import { dedupeWith } from 'effect/Array';
+import { Array, Option } from 'effect';
 import React, { type PropsWithChildren, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { CollaborationActions, createIntent, useIntentDispatcher } from '@dxos/app-framework';
 import { Event } from '@dxos/async';
 import { DXN, Obj, Ref } from '@dxos/echo';
 import { log } from '@dxos/log';
 import { useVoiceInput } from '@dxos/plugin-transcription';
-import { type Expando, getSpace, useQueue, type Space } from '@dxos/react-client/echo';
+import { type Space, getSpace, useQueue } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
-import { Input, useTranslation, type ThemedClassName } from '@dxos/react-ui';
+import { Input, type ThemedClassName, useTranslation } from '@dxos/react-ui';
 import { ChatEditor, type ChatEditorController, type ChatEditorProps, references } from '@dxos/react-ui-chat';
 import { type ScrollController } from '@dxos/react-ui-components';
 import { mx } from '@dxos/react-ui-theme';
 import { DataType } from '@dxos/schema';
 import { isNotFalsy } from '@dxos/util';
 
-import { type ChatEvent } from './events';
-import { type ChatProcessor, useBlueprints, useReferencesProvider } from '../../hooks';
+import { type AiChatProcessor, useBlueprintHandlers, useReferencesProvider } from '../../hooks';
 import { meta } from '../../meta';
 import { type Assistant } from '../../types';
 import {
   ChatActions,
   type ChatActionsProps,
-  ChatOptionsMenu,
+  ChatOptions,
   ChatPresets,
   type ChatPresetsProps,
   ChatReferences,
@@ -38,6 +37,8 @@ import {
 } from '../ChatPrompt';
 import { ChatThread as NativeChatThread, type ChatThreadProps as NativeChatThreadProps } from '../ChatThread';
 
+import { type ChatEvent } from './events';
+
 // TODO(burdon): Factor out.
 const Endcap = ({ children }: PropsWithChildren) => {
   return (
@@ -57,11 +58,8 @@ type ChatContextValue = {
   event: Event<ChatEvent>;
   space: Space;
   chat: Assistant.Chat;
-  processor: ChatProcessor;
   messages: DataType.Message[];
-
-  /** @deprecated Remove and replace with context. */
-  artifact?: Expando;
+  processor: AiChatProcessor;
 };
 
 // NOTE: Do not export.
@@ -73,43 +71,46 @@ const [ChatContextProvider, useChatContext] = createContext<ChatContextValue>('C
 
 type ChatRootProps = ThemedClassName<
   PropsWithChildren<
-    Pick<ChatContextValue, 'chat' | 'processor' | 'artifact'> & {
+    Pick<ChatContextValue, 'chat' | 'processor'> & {
       onEvent?: (event: ChatEvent) => void;
     }
   >
 >;
 
-const ChatRoot = ({ classNames, children, chat, processor, artifact, onEvent, ...props }: ChatRootProps) => {
+const ChatRoot = ({ classNames, 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 messages = useMemo(
-    () =>
-      dedupeWith(
-        [...(queue?.objects?.filter(Obj.instanceOf(DataType.Message)) ?? []), ...(processor?.messages.value ?? [])],
-        (a, b) => a.id === b.id,
-      ),
-    [queue?.objects, processor?.messages.value],
-  );
-
-  // TODO(burdon): Replace with tool.
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  useEffect(() => {
-    if (!processor?.streaming.value && queue?.objects && artifact) {
-      const message = queue.objects[queue.objects.length - 1];
-      if (dispatch && space && chat && message) {
-        void dispatch(
-          createIntent(CollaborationActions.InsertContent, {
-            target: artifact,
-            object: Ref.fromDXN(new DXN(DXN.kind.QUEUE, [...chat.queue.dxn.parts, message.id])),
-            label: 'View proposal',
-          }),
-        );
-      }
-    }
-  }, [queue, processor?.streaming.value]);
+  const pending = useRxValue(processor.messages);
+  const streaming = useRxValue(processor.streaming);
+
+  const messages = useMemo(() => {
+    const queueMessages = queue?.objects?.filter(Obj.instanceOf(DataType.Message)) ?? [];
+    return Result.match(pending, {
+      onInitial: () => queueMessages,
+      onSuccess: (pending) => Array.dedupeWith([...queueMessages, ...pending.value], (a, b) => a.id === b.id),
+      onFailure: () => queueMessages,
+    });
+  }, [queue?.objects, pending]);
+
+  // TODO(burdon): Replace with tool to select artifact.
+  // const { dispatchPromise: dispatch } = useIntentDispatcher();
+  // useEffect(() => {
+  //   if (!processor?.streaming.value && queue?.objects) {
+  //     const message = queue.objects[queue.objects.length - 1];
+  //     if (dispatch && space && chat && message) {
+  //       void dispatch(
+  //         createIntent(CollaborationActions.InsertContent, {
+  //           target: artifact,
+  //           object: Ref.fromDXN(new DXN(DXN.kind.QUEUE, [...chat.queue.dxn.parts, message.id])),
+  //           label: 'View proposal',
+  //         }),
+  //       );
+  //     }
+  //   }
+  // }, [queue, processor?.streaming.value]);
 
   // Events.
   const event = useMemo(() => new Event<ChatEvent>(), []);
@@ -117,12 +118,17 @@ const ChatRoot = ({ classNames, children, chat, processor, artifact, onEvent, ..
     return event.on((event) => {
       switch (event.type) {
         case 'toggle-debug': {
-          setDebug((debug) => !debug);
+          setDebug((current) => {
+            const debug = !current;
+            log.info('toggle-debug', { debug });
+            // log.config({ filter: debug ? 'assistant:debug' : 'info' });
+            return debug;
+          });
           break;
         }
 
         case 'submit': {
-          if (!processor.streaming.value) {
+          if (!streaming) {
             void processor.request(event.text);
           }
           break;
@@ -138,7 +144,7 @@ const ChatRoot = ({ classNames, children, chat, processor, artifact, onEvent, ..
         }
       }
     });
-  }, [event, onEvent]);
+  }, [event, onEvent, processor, streaming]);
 
   if (!space) {
     return null;
@@ -170,7 +176,7 @@ ChatRoot.displayName = 'Chat.Root';
 type ChatThreadProps = Omit<NativeChatThreadProps, 'identity' | 'space' | 'messages' | 'tools' | 'onEvent'>;
 
 const ChatThread = (props: ChatThreadProps) => {
-  const { debug, event, space, processor, messages } = useChatContext(ChatThread.displayName);
+  const { debug, event, space, messages } = useChatContext(ChatThread.displayName);
   const identity = useIdentity();
 
   const scrollerRef = useRef<ScrollController>(null);
@@ -197,7 +203,6 @@ const ChatThread = (props: ChatThreadProps) => {
       identity={identity}
       space={space}
       messages={messages}
-      tools={processor?.tools}
       onEvent={(ev) => event.emit(ev)}
     />
   );
@@ -231,6 +236,8 @@ const ChatPrompt = ({
 }: ChatPromptProps) => {
   const { t } = useTranslation(meta.id);
   const { space, event, processor } = useChatContext(ChatPrompt.displayName);
+  const streaming = useRxValue(processor.streaming);
+  const error = useRxValue(processor.error).pipe(Option.getOrUndefined);
 
   const [active, setActive] = useState(false);
   useEffect(() => {
@@ -257,16 +264,14 @@ const ChatPrompt = ({
     },
   });
 
-  const [blueprints, handleUpdateBlueprints] = useBlueprints(space, processor.context, processor.blueprintRegistry);
-
   // TODO(burdon): Reconcile with object tags.
-  const contextProvider = useReferencesProvider(space);
+  const referencesProvider = useReferencesProvider(space);
   const extensions = useMemo<Extension[]>(() => {
     return [
-      contextProvider && references({ provider: contextProvider }),
-      expandable &&
-        Prec.highest(
-          keymap.of([
+      referencesProvider && references({ provider: referencesProvider }),
+      Prec.highest(
+        keymap.of(
+          [
             {
               key: 'cmd-d',
               preventDefault: true,
@@ -275,7 +280,7 @@ const ChatPrompt = ({
                 return true;
               },
             },
-            {
+            expandable && {
               key: 'cmd-ArrowUp',
               preventDefault: true,
               run: () => {
@@ -283,7 +288,7 @@ const ChatPrompt = ({
                 return true;
               },
             },
-            {
+            expandable && {
               key: 'cmd-ArrowDown',
               preventDefault: true,
               run: () => {
@@ -291,19 +296,20 @@ const ChatPrompt = ({
                 return true;
               },
             },
-          ]),
+          ].filter(isNotFalsy),
         ),
+      ),
     ].filter(isNotFalsy);
-  }, [event, expandable, contextProvider]);
+  }, [event, expandable, referencesProvider]);
 
   const handleSubmit = useCallback<NonNullable<ChatEditorProps['onSubmit']>>(
     (text) => {
-      if (!processor.streaming.value) {
+      if (!streaming) {
         event.emit({ type: 'submit', text });
         return true;
       }
     },
-    [processor, event],
+    [streaming, event],
   );
 
   const handleEvent = useCallback<NonNullable<ChatActionsProps['onEvent']>>(
@@ -313,11 +319,17 @@ const ChatPrompt = ({
     [event],
   );
 
-  // TODO(burdon): Update context.
-  const handleUpdateReferences = useCallback<NonNullable<ChatReferencesProps['onUpdate']>>((ids) => {
-    log.info('update', { ids });
+  const handleUpdateReferences = useCallback<NonNullable<ChatReferencesProps['onUpdate']>>((dxns) => {
+    log.info('update', { dxns });
+    void processor.context.bind({ objects: dxns.map((dxn) => Ref.fromDXN(DXN.parse(dxn))) });
   }, []);
 
+  const { onUpdateBlueprint } = useBlueprintHandlers({
+    space,
+    context: processor.context,
+    blueprintRegistry: processor.blueprintRegistry,
+  });
+
   return (
     <div
       className={mx(
@@ -326,7 +338,7 @@ const ChatPrompt = ({
       )}
     >
       <Endcap>
-        <ChatStatusIndicator preset={preset} error={processor.error.value} processing={processor.streaming.value} />
+        <ChatStatusIndicator preset={preset} error={error} processing={streaming} />
       </Endcap>
 
       <ChatEditor
@@ -347,16 +359,17 @@ const ChatPrompt = ({
         onUpdate={handleUpdateReferences}
       />
 
-      <ChatOptionsMenu
+      <ChatOptions
         blueprintRegistry={processor.blueprintRegistry}
-        blueprints={blueprints}
-        onChange={handleUpdateBlueprints}
+        context={processor.context}
+        onUpdateBlueprint={onUpdateBlueprint}
       />
+
       <ChatActions
         classNames='col-span-2'
         microphone={true}
         recording={recording}
-        processing={processor.streaming.value}
+        processing={streaming}
         onEvent={handleEvent}
       >
         <>