@dxos/plugin-assistant 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/hooks/useChatToolbarActions.ts

@@ -2,21 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
-import { useMemo } from 'react';
 
 import { useOperationInvoker } from '@dxos/app-framework/ui';
 import { Chat } from '@dxos/assistant-toolkit';
-import { Filter, Obj, Query } from '@dxos/echo';
-import { runAndForwardErrors } from '@dxos/effect';
+import { Filter, Obj, Query, Type } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
-import { useQuery } from '@dxos/react-client/echo';
-import { MenuBuilder, useMenuActions } from '@dxos/react-ui-menu';
+import { MenuBuilder, useMenuBuilder } from '@dxos/react-ui-menu';
 
-import { useChatContext } from '#components';
 import { meta } from '#meta';
-import { AssistantOperation } from '#operations';
+import { AssistantOperation } from '#types';
+
+import { useChatContext } from '../components/Chat/context';
 
 export type ChatToolbarActionsProps = {
   chat?: Chat.Chat;
@@ -26,97 +24,101 @@ export type ChatToolbarActionsProps = {
 export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsProps) => {
   const { invoke } = useOperationInvoker();
   const { db } = useChatContext('useChatToolbarActions');
-  const query = companionTo
-    ? Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source()
-    : Query.select(Filter.nothing());
 
-  // TODO(wittjosiah): Query in react vs query in atom?
-  const chats = useQuery(db, query);
+  // Stable references in deps avoid circular reference issues.
+  return useMenuBuilder(
+    (get) => {
+      const chats =
+        companionTo && db
+          ? get(db.query(Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source()).atom)
+          : [];
+
+      const builder = MenuBuilder.make()
+        .root({
+          label: ['chat-toolbar.title', { ns: meta.id }],
+        })
+        .action(
+          'new',
+          {
+            label: ['new-thread.button', { ns: meta.id }],
+            icon: 'ph--plus--regular',
+            type: 'new',
+            disabled: !companionTo,
+          },
+          () => {
+            invariant(companionTo);
+            return invoke(AssistantOperation.SetCurrentChat, {
+              companionTo,
+              chat: undefined,
+            }).pipe(EffectEx.runAndForwardErrors);
+          },
+        )
+        .action(
+          'rename',
+          {
+            label: ['rename-thread.button', { ns: meta.id }],
+            icon: 'ph--magic-wand--regular',
+            type: 'rename',
+            disabled: !chat,
+          },
+          () =>
+            Effect.gen(function* () {
+              invariant(chat);
+              yield* invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId: db?.spaceId });
+            }).pipe(EffectEx.runAndForwardErrors),
+        )
+        .action(
+          'branch',
+          {
+            label: ['branch-thread.menu', { ns: meta.id }],
+            icon: 'ph--git-branch--regular',
+            type: 'branch',
+            disabled: !chat || !db,
+          },
+          () =>
+            Effect.gen(function* () {
+              invariant(chat);
+              yield* invoke(AssistantOperation.ForkChat, { chat, companionTo }, { spaceId: db?.spaceId });
+            }).pipe(EffectEx.runAndForwardErrors),
+        );
 
-  // Create stable reference for dependency array to avoid circular reference issues.
-  return useMenuActions(
-    useMemo(() => {
-      return Atom.make(() => {
-        const builder = MenuBuilder.make()
-          .root({
-            label: ['chat-toolbar.title', { ns: meta.id }],
-          })
-          .action(
-            'new',
-            {
-              label: ['new-thread.button', { ns: meta.id }],
-              icon: 'ph--plus--regular',
-              type: 'new',
-              disabled: !companionTo,
-            },
-            () => {
-              invariant(companionTo);
-              return invoke(AssistantOperation.SetCurrentChat, {
-                companionTo,
-                chat: undefined,
-              }).pipe(runAndForwardErrors);
-            },
-          )
-          .action(
-            'rename',
-            {
-              label: ['rename-thread.button', { ns: meta.id }],
-              icon: 'ph--magic-wand--regular',
-              type: 'rename',
-              disabled: !chat,
-            },
-            () =>
-              Effect.gen(function* () {
-                invariant(chat);
-                yield* invoke(AssistantOperation.UpdateChatName, { chat });
-              }).pipe(runAndForwardErrors),
-          )
-          .action(
-            'branch',
-            {
-              label: ['branch-thread.menu', { ns: meta.id }],
-              icon: 'ph--git-branch--regular',
-              type: 'branch',
-              disabled: true,
-            },
-            () => {},
-          );
+      if (chats.length > 0) {
+        builder.group(
+          'chats',
+          {
+            label: ['chat-history.label', { ns: meta.id }],
+            icon: 'ph--clock-counter-clockwise--regular',
+            selectCardinality: 'single',
+            variant: 'dropdownMenu',
+          },
+          (builder) => {
+            chats
+              // TODO(wittjosiah): This should be the default sort order.
+              .toSorted((a, b) => a.id.localeCompare(b.id))
+              .forEach((chat) => {
+                get(Obj.atomProperty(chat, 'name'));
 
-        if (chats.length > 0) {
-          builder.group(
-            'chats',
-            {
-              label: ['chat-history.label', { ns: meta.id }],
-              icon: 'ph--clock-counter-clockwise--regular',
-              selectCardinality: 'single',
-              variant: 'dropdownMenu',
-            },
-            (builder) => {
-              chats
-                // TODO(wittjosiah): This should be the default sort order.
-                .toSorted((a, b) => a.id.localeCompare(b.id))
-                .forEach((chat) => {
-                  builder.action(
-                    chat.id,
-                    {
-                      label: Obj.getLabel(chat) ?? ['object-name.placeholder', { ns: Chat.Chat.typename }],
-                    },
-                    () =>
-                      Effect.gen(function* () {
-                        invariant(companionTo);
-                        yield* invoke(AssistantOperation.SetCurrentChat, {
-                          companionTo,
-                          chat,
-                        });
-                      }).pipe(runAndForwardErrors),
-                  );
-                });
-            },
-          );
-        }
+                builder.action(
+                  chat.id,
+                  {
+                    label: Obj.getLabel(chat) ?? ['object-name.placeholder', { ns: Type.getTypename(Chat.Chat) }],
+                  },
+                  () =>
+                    Effect.gen(function* () {
+                      invariant(companionTo);
+                      yield* invoke(AssistantOperation.SetCurrentChat, {
+                        companionTo,
+                        chat,
+                      });
+                    }).pipe(EffectEx.runAndForwardErrors),
+                );
+              });
+          },
+        );
+      }
 
-        return builder.build();
-      });
-    }, [chats.length, db?.spaceId, companionTo?.id, chat?.id, invoke]),
+      return builder.build();
+    },
+    [db?.spaceId, companionTo?.id, chat?.id, invoke],
   );
 };

package/src/hooks/useContextBinder.ts

@@ -6,19 +6,19 @@ import { type Registry, RegistryContext } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
 import { useContext, useState } from 'react';
 
-import { AiContextBinder } from '@dxos/assistant';
+import { AiContext } from '@dxos/assistant';
 import { Feed } from '@dxos/echo';
-import { createFeedServiceLayer } from '@dxos/echo-db';
-import { runAndForwardErrors } from '@dxos/effect';
+import { createFeedServiceLayer } from '@dxos/echo-client';
+import { EffectEx } from '@dxos/effect';
 import { type Space } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
 export const useContextBinder = (
   space: Space | undefined,
   feed: Feed.Feed | undefined,
-): AiContextBinder | undefined => {
+): AiContext.Binder | undefined => {
   const registry = useContext(RegistryContext) as Registry.Registry;
-  const [binder, setBinder] = useState<AiContextBinder>();
+  const [binder, setBinder] = useState<AiContext.Binder>();
 
   useAsyncEffect(async () => {
     setBinder(undefined);
@@ -27,10 +27,10 @@ export const useContextBinder = (
     }
 
     const feedServiceLayer = createFeedServiceLayer(space.queues);
-    const runtime = await runAndForwardErrors(
+    const runtime = await EffectEx.runAndForwardErrors(
       Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
     );
-    const binder = new AiContextBinder({ feed, runtime, registry });
+    const binder = new AiContext.Binder({ feed, runtime, registry });
     await binder.open();
     setBinder(binder);
 

package/src/hooks/useContextObjects.ts

@@ -5,17 +5,18 @@
 import { Atom, useAtomValue } from '@effect-atom/atom-react';
 import { useCallback } from 'react';
 
-import { type AiContextBinder } from '@dxos/assistant';
-import { type DXN, type Database, type Obj } from '@dxos/echo';
+import { type AiContext } from '@dxos/assistant';
+import { type Database, type Obj } from '@dxos/echo';
+import { type URI } from '@dxos/keys';
 
 export type UseContextObjectsProps = {
   db?: Database.Database;
-  context?: AiContextBinder;
+  context?: AiContext.Binder;
 };
 
 export type UseContextObjects = {
   objects: Obj.Unknown[];
-  onUpdateObject: (dxn: DXN, checked: boolean) => Promise<void>;
+  onUpdateObject: (dxn: URI.URI, checked: boolean) => Promise<void>;
 };
 
 const emptyObjectsAtom = Atom.make<Obj.Unknown[]>([]);
@@ -27,7 +28,7 @@ export const useContextObjects = ({ db, context }: UseContextObjectsProps): UseC
   const objects = useAtomValue(context?.objects ?? emptyObjectsAtom);
 
   const handleUpdateObject = useCallback<UseContextObjects['onUpdateObject']>(
-    async (dxn: DXN, checked: boolean) => {
+    async (dxn: URI.URI, checked: boolean) => {
       if (!db || !context) {
         return;
       }

package/src/hooks/useDebug.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCallback } from 'react';
+
+import { trim } from '@dxos/util';
+
+import { type AiChatProcessor } from '../processor';
+
+/**
+ * Returns an async callback that logs the chat's current context, system prompt,
+ * and resolved tools to the browser console under a collapsible group.
+ * Used by the chat's debug-toggle event handler.
+ */
+export const useDebug = ({ processor }: { processor: AiChatProcessor }) => {
+  return useCallback(async () => {
+    const objects = processor.context.getObjects();
+    const blueprints = processor.context.getBlueprints();
+    const system = await processor.getSystemPrompt();
+    const tools = (await processor.getTools()) ?? {};
+    console.group('Chat', { objects, blueprints });
+    try {
+      console.log(trim`
+        System Prompt:
+        ${system}
+      `);
+      console.log(trim`
+        Tools:
+        ${Object.values(tools)
+          .map((tool) => JSON.stringify(tool, null, 2))
+          .join('\n')}
+      `);
+    } finally {
+      console.groupEnd();
+    }
+  }, [processor]);
+};

package/src/hooks/useFilteredTypes.ts

@@ -5,8 +5,20 @@
 import * as Option from 'effect/Option';
 import { useEffect, useState } from 'react';
 
-import { type Database, type Type } from '@dxos/echo';
-import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
+import { type Database, Type } from '@dxos/echo';
+import { HiddenAnnotation, getTypeAnnotation } from '@dxos/echo/Annotation';
+import { Kind as EntityKind } from '@dxos/echo/Entity';
+
+const getFilteredTypes = (db: Database.Database): Type.AnyEntity[] =>
+  Array.from(
+    new Set(
+      db.graph.registry
+        .list()
+        .filter(Type.isType)
+        .filter((schema) => getTypeAnnotation(Type.getSchema(schema))?.kind !== EntityKind.Relation)
+        .filter((schema) => !HiddenAnnotation.get(Type.getSchema(schema)).pipe(Option.getOrElse(() => false))),
+    ),
+  );
 
 // TODO(burdon): Pass in filter.
 // TODO(wittjosiah): Factor out.
@@ -17,20 +29,10 @@ export const useFilteredTypes = (db?: Database.Database): Type.AnyEntity[] => {
       return;
     }
 
-    return db.schemaRegistry.query({ location: ['database', 'runtime'] }).subscribe(
-      (query) => {
-        const types = Array.from(
-          new Set(
-            query.results
-              .filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation)
-              .filter((schema) => !SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))),
-          ),
-        );
-
-        setTypes(types);
-      },
-      { fire: true },
-    );
+    setTypes(getFilteredTypes(db));
+    return db.graph.registry.changed.on(() => {
+      setTypes(getFilteredTypes(db));
+    });
   }, [db]);
 
   return types;

package/src/hooks/usePresets.ts

@@ -4,13 +4,13 @@
 
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import { type ChatPromptProps } from '#components';
+import { type ChatPresetProps } from '#types';
 
 import { type AiServicePreset, AiServicePresets } from '../processor';
 
 export type UsePresets = {
   preset: AiServicePreset | undefined;
-} & Pick<ChatPromptProps, 'presets' | 'onPresetChange'>;
+} & Pick<ChatPresetProps, 'presets' | 'onPresetChange'>;
 
 export const usePresets = (online: boolean): UsePresets => {
   // TODO(burdon): Memo preset for provider.
@@ -19,15 +19,17 @@ export const usePresets = (online: boolean): UsePresets => {
     () => AiServicePresets.filter((preset) => online === (preset.provider === 'dxos-remote')),
     [online],
   );
+
   const presetOptions = useMemo(
     () => presets.map(({ id, model, label }) => ({ id, label: label ?? model })),
     [presets],
   );
+
   useEffect(() => {
     setPreset(presets[0]);
   }, [presets]);
 
-  const handlePresetChange = useCallback<NonNullable<ChatPromptProps['onPresetChange']>>(
+  const handlePresetChange = useCallback<NonNullable<ChatPresetProps['onPresetChange']>>(
     (id) => {
       const preset = presets.find((preset) => preset.id === id);
       if (preset) {

package/src/hooks/useReferencesProvider.ts

@@ -27,21 +27,13 @@ export const useReferencesProvider = (space?: Space): ReferencesProvider | undef
 
         const objects = await space.db.query(Filter.everything()).run();
 
-        return (
-          objects
-            // TODO(burdon): Remove cast ??? (+ two instances below).
-            // .map((object) => {
-            //   log.info('object', { object, label: Obj.getLabel(object as any) });
-            //   return object;
-            // })
-            .filter((object) => stringMatch(query, Obj.getLabel(object as any) ?? ''))
-            // TODO(dmaretskyi): `Type.getDXN` (at the point of writing) didn't work here as it was schema-only.
-            .filter((object) => !!Obj.getDXN(object as Obj.Unknown))
-            .map((object) => ({
-              uri: Obj.getDXN(object as any).toString(),
-              label: Obj.getLabel(object as any) ?? '',
-            }))
-        );
+        return objects
+          .filter(Obj.isObject)
+          .filter((object) => stringMatch(query, Obj.getLabel(object) ?? ''))
+          .map((object) => ({
+            uri: Obj.getURI(object),
+            label: Obj.getLabel(object) ?? '',
+          }));
       },
       resolveReference: async ({ uri }) => {
         const object = await space.db.query(Filter.id(uri)).first();

package/src/index.ts

@@ -3,10 +3,6 @@
 //
 
 export * from './blueprints';
-export * from './components';
-export * from './hooks';
 export * from './meta';
-export * from './translations';
+export * from './paths';
 export * from './types';
-
-export * from './AssistantPlugin';

package/src/meta.ts

@@ -2,23 +2,42 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Plugin } from '@dxos/app-framework';
+import { Plugin } from '@dxos/app-framework';
+import { DXN } from '@dxos/keys';
 import { trim } from '@dxos/util';
 
-export const meta: Plugin.Meta = {
-  id: 'org.dxos.plugin.assistant',
+export const meta = Plugin.makeMeta({
+  key: DXN.make('org.dxos.plugin.assistant'),
   name: 'Assistant',
+  author: 'DXOS',
   description: trim`
-    Intelligent AI assistant that can analyze and interact with objects across your spaces.
-    Chat naturally to get insights, search content, and perform actions using AI-powered context awareness.
+    AssistantPlugin brings a conversational AI assistant into DXOS Composer, letting users chat naturally
+    with objects in their spaces. Every Chat is a first-class ECHO object — messages are persisted,
+    replicated across peers in real time, and can be bound to any document or collection as a companion
+    panel that appears alongside the primary view.
+
+    AI capabilities are delivered through a flexible multi-provider model layer. Users can route requests
+    to the DXOS Edge service, a locally running Ollama instance, or LM Studio, and switch providers at
+    any time in Settings. Each provider can be configured with a preferred model, and the runtime
+    automatically falls back when a provider is unavailable.
+
+    Blueprints give every chat a specialised identity. Built-in blueprints cover general assistance,
+    web browsing, database interaction, web search, Discord and Linear integration, autonomous agents,
+    planning, memory, automation, and a wizard for authoring new blueprints. Binding a blueprint
+    changes the system instructions and the tool set exposed to the model in a single step.
+
+    Tool execution runs through the DXOS compute runtime so every AI action — opening a document,
+    searching the web, querying a database — produces a structured execution trace. The optional
+    TracePanel visualises that trace as a commit graph or raw JSON, giving developers full observability
+    into what the model did and why.
   `,
   icon: 'ph--sparkle--regular',
   iconHue: 'sky',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-assistant',
-  tags: ['labs'],
-};
+  spec: 'PLUGIN.mdl',
+});
 
-export const ASSISTANT_DIALOG = `${meta.id}.assistant.dialog`;
+export const ASSISTANT_DIALOG = DXN.make(`${meta.id}.assistantDialog`);
 
 /** Companion variant identifier for the assistant chat panel. */
 export const ASSISTANT_COMPANION_VARIANT = 'assistant-chat';

package/src/operations/create-chat.ts

@@ -5,20 +5,18 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { AiContextBinder } from '@dxos/assistant';
+import { AiContext } from '@dxos/assistant';
 import { Chat, DatabaseBlueprint, AgentWizardBlueprint } from '@dxos/assistant-toolkit';
-import { Blueprint } from '@dxos/blueprints';
-import { Feed, Filter, Obj, Ref } from '@dxos/echo';
-import { createFeedServiceLayer } from '@dxos/echo-db';
+import { Blueprint, Operation } from '@dxos/compute';
+import { Feed, Obj, Ref } from '@dxos/echo';
+import { createFeedServiceLayer } from '@dxos/echo-client';
 import { invariant } from '@dxos/invariant';
-import { Operation } from '@dxos/operation';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { ClientCapabilities } from '@dxos/plugin-client';
 
 import { AssistantBlueprint } from '#blueprints';
+import { AssistantOperation } from '#types';
 
-import { CreateChat } from './definitions';
-
-const handler: Operation.WithHandler<typeof CreateChat> = CreateChat.pipe(
+const handler: Operation.WithHandler<typeof AssistantOperation.CreateChat> = AssistantOperation.CreateChat.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ db, name, addToSpace = true }) {
       const registry = yield* Capability.get(Capabilities.AtomRegistry);
@@ -32,42 +30,21 @@ const handler: Operation.WithHandler<typeof CreateChat> = CreateChat.pipe(
         space.db.add(chat);
       }
 
-      // TODO(wittjosiah): This should be a space-level setting.
-      // TODO(burdon): Clone when activated. Copy-on-write for template.
-      const blueprints = yield* Effect.promise(() => db.query(Filter.type(Blueprint.Blueprint)).run());
-      let defaultAssistantBlueprint = blueprints.find((blueprint) => blueprint.key === AssistantBlueprint.key);
-      if (!defaultAssistantBlueprint) {
-        defaultAssistantBlueprint = db.add(AssistantBlueprint.make());
-      }
-      let defaultDatabaseBlueprint = blueprints.find((blueprint) => blueprint.key === DatabaseBlueprint.key);
-      if (!defaultDatabaseBlueprint) {
-        defaultDatabaseBlueprint = db.add(DatabaseBlueprint.make());
-      }
-      let defaultAgentWizardBlueprint = blueprints.find((blueprint) => blueprint.key === AgentWizardBlueprint.key);
-      if (!defaultAgentWizardBlueprint) {
-        defaultAgentWizardBlueprint = db.add(AgentWizardBlueprint.make());
-      }
       // Dynamic import to avoid circular dependency with the barrel that also exports BlueprintManagerHandlers.
       const { BlueprintManagerBlueprint } = yield* Effect.promise(() => import('@dxos/assistant-toolkit'));
-      let defaultBlueprintManagerBlueprint = blueprints.find(
-        (blueprint) => blueprint.key === BlueprintManagerBlueprint.key,
-      );
-      if (!defaultBlueprintManagerBlueprint) {
-        defaultBlueprintManagerBlueprint = db.add(BlueprintManagerBlueprint.make());
-      }
 
       const feedServiceLayer = createFeedServiceLayer(space.queues);
       const runtime = yield* Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer));
-      const binder = new AiContextBinder({ feed, runtime, registry });
+      const binder = new AiContext.Binder({ feed, runtime, registry });
+
+      // Bind default blueprints via registry refs — no DB clone needed since the ECHO ref
+      // resolver already spans the hypergraph registry.
       yield* Effect.promise(() =>
-        binder.use((b: AiContextBinder) =>
+        binder.use((b: AiContext.Binder) =>
           b.bind({
-            blueprints: [
-              Ref.make(defaultAssistantBlueprint!),
-              Ref.make(defaultDatabaseBlueprint!),
-              Ref.make(defaultAgentWizardBlueprint!),
-              Ref.make(defaultBlueprintManagerBlueprint!),
-            ],
+            blueprints: [AssistantBlueprint, DatabaseBlueprint, AgentWizardBlueprint, BlueprintManagerBlueprint].map(
+              ({ key }) => Ref.fromURI(Blueprint.registryURI(key)),
+            ),
           }),
         ),
       );