@dxos/plugin-assistant 0.8.4-main.67995b8 → 0.8.4-main.f5c0578

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/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}
       >
         <>

package/src/components/ChatContainer.tsx

@@ -2,40 +2,64 @@
 // Copyright 2025 DXOS.org
 //
 
-import React from 'react';
+import React, { useEffect } from 'react';
 
 import { Capabilities, useCapability } from '@dxos/app-framework';
-import { type AssociatedArtifact } from '@dxos/blueprints';
 import { getSpace } from '@dxos/client/echo';
 import { StackItem } from '@dxos/react-ui-stack';
+import { type MaybePromise } from '@dxos/util';
 
-import { Chat } from './Chat';
-import { useChatProcessor, useChatServices } from '../hooks';
+import {
+  type AiChatProcessor,
+  useBlueprintRegistry,
+  useChatProcessor,
+  useChatServices,
+  useOnline,
+  usePresets,
+} from '../hooks';
 import { meta } from '../meta';
 import { type Assistant } from '../types';
 
+import { Chat } from './Chat';
+
 export type ChatContainerProps = {
-  role: string;
   chat: Assistant.Chat;
-  artifact?: AssociatedArtifact;
+  role?: string;
+  onProcessorReady?: (processor: AiChatProcessor) => MaybePromise<void>;
 };
 
-export const ChatContainer = ({ role, chat, artifact }: ChatContainerProps) => {
+export const ChatContainer = ({ chat, onProcessorReady }: ChatContainerProps) => {
   const space = getSpace(chat);
   const settings = useCapability(Capabilities.SettingsStore).getStore<Assistant.Settings>(meta.id)?.value;
-  const services = useChatServices({ space });
-  const processor = useChatProcessor({ chat, services, settings });
-  if (!processor) {
+  const services = useChatServices({ space, chat });
+  const [online, setOnline] = useOnline();
+  const { preset, ...chatProps } = usePresets(online);
+  const blueprintRegistry = useBlueprintRegistry();
+  const processor = useChatProcessor({ space, chat, preset, services, blueprintRegistry, settings });
+
+  useEffect(() => {
+    if (processor && onProcessorReady) {
+      const timeout = setTimeout(() => onProcessorReady(processor));
+      return () => clearTimeout(timeout);
+    }
+  }, [processor, onProcessorReady]);
+
+  if (!chat || !processor) {
     return null;
   }
 
-  // TODO(burdon): Add attention attributes.
   return (
     <StackItem.Content classNames='container-max-width'>
-      <Chat.Root chat={chat} processor={processor} artifact={artifact}>
+      <Chat.Root chat={chat} processor={processor}>
         <Chat.Thread />
-        <div className='pbe-4 pis-2 pie-2'>
-          <Chat.Prompt classNames='border border-subduedSeparator rounded-md' />
+        <div className='p-2'>
+          <Chat.Prompt
+            {...chatProps}
+            classNames='p-2 border border-transparent rounded-md'
+            preset={preset?.id}
+            online={online}
+            onChangeOnline={setOnline}
+          />
         </div>
       </Chat.Root>
     </StackItem.Content>

package/src/components/ChatDialog.tsx

@@ -4,16 +4,17 @@
 
 import React, { useCallback, useState } from 'react';
 
-import { useCapability, Capabilities } from '@dxos/app-framework';
+import { Capabilities, useCapability } from '@dxos/app-framework';
 import { getSpace } from '@dxos/client/echo';
 import { useTranslation } from '@dxos/react-ui';
 import { ChatDialog as NativeChatDialog } from '@dxos/react-ui-chat';
 
-import { Chat, type ChatRootProps } from './Chat';
-import { useChatProcessor, useChatServices } from '../hooks';
+import { useBlueprintRegistry, useChatProcessor, useChatServices, useOnline, usePresets } from '../hooks';
 import { meta } from '../meta';
 import { type Assistant } from '../types';
 
+import { Chat, type ChatRootProps } from './Chat';
+
 export type ChatDialogProps = {
   chat?: Assistant.Chat;
 };
@@ -23,8 +24,11 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
 
   const space = getSpace(chat);
   const settings = useCapability(Capabilities.SettingsStore).getStore<Assistant.Settings>(meta.id)?.value;
-  const services = useChatServices({ space });
-  const processor = useChatProcessor({ chat, services, settings });
+  const services = useChatServices({ space, chat });
+  const [online, setOnline] = useOnline();
+  const { preset, ...chatProps } = usePresets(online);
+  const blueprintRegistry = useBlueprintRegistry();
+  const processor = useChatProcessor({ space, chat, preset, services, blueprintRegistry, settings });
 
   // TODO(burdon): Refocus when open.
   const [open, setOpen] = useState(true);
@@ -54,7 +58,7 @@ export const ChatDialog = ({ chat }: ChatDialogProps) => {
           <Chat.Thread />
         </NativeChatDialog.Content>
         <NativeChatDialog.Footer>
-          <Chat.Prompt expandable />
+          <Chat.Prompt {...chatProps} preset={preset?.id} online={online} onChangeOnline={setOnline} expandable />
         </NativeChatDialog.Footer>
       </NativeChatDialog.Root>
     </Chat.Root>

package/src/components/ChatPrompt/ChatOptions.tsx

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type AiContextBinder } from '@dxos/assistant';
+import { type Blueprint } from '@dxos/blueprints';
+import { DropdownMenu, Icon, IconButton, useTranslation } from '@dxos/react-ui';
+
+import { useBlueprints } from '../../hooks';
+import { meta } from '../../meta';
+
+export type ChatOptionsProps = {
+  context?: AiContextBinder;
+  blueprintRegistry?: Blueprint.Registry;
+  onUpdateBlueprint?: (key: string, isActive: boolean) => void;
+};
+
+/**
+ * Manages the runtime context for the chat.
+ */
+// TODO(burdon): Refactor this as a Dialog (and move the object selector here also).
+export const ChatOptions = ({ context, blueprintRegistry, onUpdateBlueprint }: ChatOptionsProps) => {
+  const { t } = useTranslation(meta.id);
+
+  // TODO(burdon): Possibly constrain query as registry grows.
+  const blueprints = useMemo(() => blueprintRegistry?.query() ?? [], [blueprintRegistry]);
+
+  const activeBlueprints = useBlueprints({ context });
+
+  return (
+    <DropdownMenu.Root>
+      <DropdownMenu.Trigger asChild>
+        <IconButton icon='ph--plus--regular' variant='ghost' size={5} iconOnly label={t('button add blueprint')} />
+      </DropdownMenu.Trigger>
+      <DropdownMenu.Portal>
+        <DropdownMenu.Content side='left'>
+          <DropdownMenu.Viewport>
+            {blueprints.map((blueprint) => (
+              <DropdownMenu.CheckboxItem
+                key={blueprint.key}
+                checked={activeBlueprints?.get(blueprint.key) !== undefined}
+                onCheckedChange={(checked) => onUpdateBlueprint?.(blueprint.key, !!checked)}
+                classNames='gap-2'
+              >
+                <div className='flex-1 min-is-0'>{blueprint.name}</div>
+                <DropdownMenu.ItemIndicator asChild>
+                  <Icon icon='ph--check--regular' size={4} />
+                </DropdownMenu.ItemIndicator>
+              </DropdownMenu.CheckboxItem>
+            ))}
+          </DropdownMenu.Viewport>
+          <DropdownMenu.Arrow />
+        </DropdownMenu.Content>
+      </DropdownMenu.Portal>
+    </DropdownMenu.Root>
+  );
+};

package/src/components/ChatPrompt/ChatReferences.tsx

@@ -4,7 +4,7 @@
 
 import React, { useCallback } from 'react';
 
-import { type ContextBinder } from '@dxos/assistant';
+import { type AiContextBinder } from '@dxos/assistant';
 import { type Space } from '@dxos/client/echo';
 import { Filter, Obj, Ref } from '@dxos/echo';
 import { type ThemedClassName, useAsyncState, useTranslation } from '@dxos/react-ui';
@@ -16,26 +16,28 @@ import { meta } from '../../meta';
 
 export type ChatReferencesProps = ThemedClassName<{
   space: Space;
-  context: ContextBinder;
-  onUpdate?: (ids: string[]) => void;
+  context: AiContextBinder;
+  onUpdate?: (dxns: string[]) => void;
 }>;
 
 export const ChatReferences = ({ classNames, space, context, onUpdate }: ChatReferencesProps) => {
-  const { t: _t } = useTranslation(meta.id);
+  const { t } = useTranslation(meta.id);
 
   const [items] = useAsyncState<TagPickerItemData[]>(async () => {
     const objects = await Ref.Array.loadAll(context.objects.value ?? []);
-    return objects.filter(isNonNullable).map((obj) => ({ id: obj.id, label: Obj.getLabel(obj) ?? obj.id }));
+    return objects
+      .filter(isNonNullable)
+      .map((obj) => ({ id: Obj.getDXN(obj).toString(), label: Obj.getLabel(obj) ?? Obj.getTypename(obj) ?? obj.id }));
   }, [context]);
 
   const handleSearch = useCallback<NonNullable<TagPickerOptions['onSearch']>>(
-    (text, ids) => {
+    (text, dxns) => {
       // TODO(burdon): Filter by Item tag (e.g., exclude "contacts") and Query by object label.
       // TODO(burdon): Change to Filter.text().
       const objects = space.db.query(Filter.everything()).runSync();
       return objects
-        .map(({ object }) => ({ id: object.id, label: Obj.getLabel(object) ?? '' }))
-        .filter(({ id, label }) => !ids.includes(id) && label.toLocaleLowerCase().includes(text.toLocaleLowerCase()));
+        .map(({ object }) => ({ id: Obj.getDXN(object).toString(), label: Obj.getLabel(object) ?? '' }))
+        .filter(({ id, label }) => !dxns.includes(id) && label.toLocaleLowerCase().includes(text.toLocaleLowerCase()));
     },
     [space],
   );
@@ -44,7 +46,7 @@ export const ChatReferences = ({ classNames, space, context, onUpdate }: ChatRef
     <TagPicker
       classNames={mx('h-[1.75rem] text-sm', classNames)}
       mode='multi-select'
-      // placeholder={t('context objects placeholder')}
+      placeholder={t('context objects placeholder')}
       items={items}
       onSearch={handleSearch}
       onUpdate={onUpdate}

package/src/components/ChatPrompt/index.ts

@@ -3,7 +3,7 @@
 //
 
 export * from './ChatActions';
-export * from './ChatOptionsMenu';
+export * from './ChatOptions';
 export * from './ChatPresets';
 export * from './ChatReferences';
 export * from './ChatStatusIndicator';