@dxos/plugin-assistant 0.8.4-main.c4373fc → 0.8.4-main.d9fc60f731

package/src/hooks/useChatProcessor.ts

@@ -2,23 +2,35 @@
 // Copyright 2025 DXOS.org
 //
 
-import { RegistryContext } from '@effect-rx/rx-react';
-import type * as Runtime from 'effect/Runtime';
-import { useContext, useMemo } from 'react';
+import { RegistryContext } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { useContext, useMemo, useState } from 'react';
 
-import { AiConversation } from '@dxos/assistant';
-import { type Blueprint } from '@dxos/blueprints';
+import { AiService, OpaqueToolkit } from '@dxos/ai';
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/ui';
+import { AiSession } from '@dxos/assistant';
+import { type Chat } from '@dxos/assistant-toolkit';
+import { Credential, OperationRegistry, ServiceResolver } from '@dxos/compute';
+import { Database, Feed, Ref, type Registry } from '@dxos/echo';
+import { createFeedServiceLayer } from '@dxos/echo-db';
+import { runAndForwardErrors } from '@dxos/effect';
+import { AgentService } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { type Queue } from '@dxos/react-client/echo';
+import { type Space } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
 
-import { AiChatProcessor, type AiChatServices, type AiServicePreset } from '../processor';
-import { type Assistant } from '../types';
+import { type Assistant } from '#types';
+
+import { AiChatProcessor, type AiServicePreset } from '../processor';
 
 export type UseChatProcessorProps = {
-  chat?: Assistant.Chat;
+  space?: Space;
+  chat?: Chat.Chat;
   preset?: AiServicePreset;
-  services?: () => Promise<Runtime.Runtime<AiChatServices>>;
-  blueprintRegistry?: Blueprint.Registry;
+  runtime?: Capabilities.ProcessManagerRuntime;
+  registry?: Registry.Registry;
   settings?: Assistant.Settings;
 };
 
@@ -26,41 +38,69 @@ export type UseChatProcessorProps = {
  * Configure and create AiChatProcessor.
  */
 export const useChatProcessor = ({
+  space,
   chat,
   preset,
-  services,
-  blueprintRegistry,
+  runtime,
+  registry,
   settings,
 }: UseChatProcessorProps): AiChatProcessor | undefined => {
   const observableRegistry = useContext(RegistryContext);
 
-  // Create conversation from chat queue.
-  const conversation = useMemo(() => {
-    if (!chat?.queue.target) {
+  const [session, setSession] = useState<AiSession.Session>();
+  useAsyncEffect(async () => {
+    if (!space || !chat) {
       return;
     }
 
-    return new AiConversation({ queue: chat.queue.target as Queue<any> });
-  }, [chat?.queue.target]);
+    const feedTarget = chat.feed.target;
+    if (!feedTarget) {
+      return;
+    }
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const runtime = await runAndForwardErrors(
+      Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
+    );
+    const session = new AiSession.Session({
+      feed: feedTarget,
+      runtime,
+      registry: observableRegistry,
+    });
+    await session.open();
+    setSession(session);
+    return () => {
+      void session.close();
+      setSession(undefined);
+    };
+  }, [space, chat?.feed.target]);
+
+  const feed = chat?.feed.target;
+  const serviceResolver = useCapability(Capabilities.ServiceResolver);
 
-  // Create processor.
   const processor = useMemo(() => {
-    if (!services || !conversation) {
+    if (!runtime || !session || !chat || !feed || !space) {
       return undefined;
     }
 
-    log('creating processor', {
-      preset,
-      model: preset?.model,
-      settings,
-    });
+    const spaceLayer = ServiceResolver.provide(
+      { space: space.id },
+      Database.Service,
+      Feed.FeedService,
+      Credential.CredentialsService,
+      AiService.AiService,
+      AgentService.AgentService,
+      OperationRegistry.Service,
+      OpaqueToolkit.OpaqueToolkitProvider,
+    ).pipe(Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, serviceResolver)));
 
-    return new AiChatProcessor(conversation, services, {
+    log('creating processor', { preset, model: preset?.model, settings });
+    return new AiChatProcessor(session, runtime, feed, spaceLayer, {
+      chat: chat ? Ref.make(chat) : undefined,
       observableRegistry,
-      blueprintRegistry,
+      registry,
       model: preset?.model,
     });
-  }, [services, conversation, blueprintRegistry, preset]);
+  }, [runtime, session, registry, preset, chat, feed, space?.id]);
 
   return processor;
 };

package/src/hooks/useChatServices.ts

@@ -2,48 +2,27 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Effect from 'effect/Effect';
-import type * as Runtime from 'effect/Runtime';
-import { useMemo } from 'react';
-
-import { useCapability } from '@dxos/app-framework';
-import { type Space } from '@dxos/client/echo';
-import { TracingService } from '@dxos/functions';
-import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/ui';
+import { getPersonalSpace } from '@dxos/app-toolkit';
+import { type Key } from '@dxos/echo';
 import { useClient } from '@dxos/react-client';
 
-import { type AiChatServices } from '../processor';
-import { type Assistant } from '../types';
-
 export type UseChatServicesProps = {
-  space?: Space;
-  chat?: Assistant.Chat;
+  id?: Key.SpaceId;
 };
 
 /**
- * Construct service layer.
+ * Resolves the shared {@link Capabilities.ProcessManagerRuntime} for the given space.
+ *
+ * The runtime itself is space-agnostic; the returned value can be used to run
+ * effects that pipe through {@link ServiceResolver.provide} (or the
+ * `useSpaceCallback`/`useSpaceService` hooks) with the resolved {@link Key.SpaceId}.
  */
-// TODO(dmaretskyi): Better return type.
-export const useChatServices = ({
-  space,
-  chat,
-}: UseChatServicesProps): (() => Promise<Runtime.Runtime<AiChatServices>>) | undefined => {
+export const useChatServices = ({ id }: UseChatServicesProps) => {
   const client = useClient();
-  space ??= client.spaces.default;
-
-  const computeRuntimeResolver = useCapability(AutomationCapabilities.ComputeRuntime);
+  id ??= getPersonalSpace(client)?.id;
 
-  return useMemo(() => {
-    const runtime = computeRuntimeResolver.getRuntime(space.id);
-    return () =>
-      runtime.runPromise(
-        Effect.gen(function* () {
-          return yield* Effect.runtime<AiChatServices>().pipe(
-            Effect.provide(
-              chat?.traceQueue?.target ? TracingService.layerQueue(chat.traceQueue?.target) : TracingService.layerNoop,
-            ),
-          );
-        }),
-      );
-  }, [space, chat?.traceQueue?.target]);
+  const runtime = useCapability(Capabilities.ProcessManagerRuntime);
+  return id ? runtime : undefined;
 };

package/src/hooks/useChatToolbarActions.ts

@@ -0,0 +1,120 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Filter, Obj, Query, Type } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+import { useQuery } from '@dxos/react-client/echo';
+import { MenuBuilder, useMenuBuilder } from '@dxos/react-ui-menu';
+
+import { useChatContext } from '#components';
+import { meta } from '#meta';
+import { AssistantOperation } from '#types';
+
+export type ChatToolbarActionsProps = {
+  chat?: Chat.Chat;
+  companionTo?: Obj.Unknown;
+};
+
+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 projection of chat identity + label so the menu rebuilds when a chat is renamed
+  // (same count, same ids → without this the history labels go stale).
+  const chatsVersion = chats.map((chat) => `${chat.id}:${Obj.getLabel(chat) ?? ''}`).join('|');
+
+  // Stable references in deps avoid circular reference issues.
+  return useMenuBuilder(() => {
+    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 }, { spaceId: db?.spaceId });
+          }).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) => {
+              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(runAndForwardErrors),
+              );
+            });
+        },
+      );
+    }
+
+    return builder.build();
+  }, [chatsVersion, db?.spaceId, companionTo?.id, chat?.id, invoke]);
+};

package/src/hooks/useContextBinder.ts

@@ -2,17 +2,42 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useMemo } from 'react';
+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 { type Space } from '@dxos/react-client/echo';
+import { useAsyncEffect } from '@dxos/react-ui';
 
-import { type Assistant } from '../types';
+export const useContextBinder = (
+  space: Space | undefined,
+  feed: Feed.Feed | undefined,
+): AiContext.Binder | undefined => {
+  const registry = useContext(RegistryContext) as Registry.Registry;
+  const [binder, setBinder] = useState<AiContext.Binder>();
 
-export const useContextBinder = (chat: Assistant.Chat | undefined): AiContextBinder | undefined => {
-  const binder = useMemo(() => {
-    const queue = chat?.queue.target;
-    return queue && new AiContextBinder(queue);
-  }, [chat]);
+  useAsyncEffect(async () => {
+    setBinder(undefined);
+    if (!space || !feed) {
+      return;
+    }
+
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const runtime = await runAndForwardErrors(
+      Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
+    );
+    const binder = new AiContext.Binder({ feed, runtime, registry });
+    await binder.open();
+    setBinder(binder);
+
+    return () => {
+      void binder.close();
+    };
+  }, [space, feed]);
 
   return binder;
 };

package/src/hooks/useContextObjects.ts

@@ -2,53 +2,46 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
 import { useCallback } from 'react';
 
-import { type AiContextBinder } from '@dxos/assistant';
-import { type DXN, type Obj, Ref } from '@dxos/echo';
-import { log } from '@dxos/log';
-import { type Space } from '@dxos/react-client/echo';
-import { isNonNullable } from '@dxos/util';
+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?: AiContext.Binder;
+};
 
 export type UseContextObjects = {
-  objects: Obj.Any[];
-  onUpdateObject: (dxn: DXN, checked: boolean) => Promise<void>;
+  objects: Obj.Unknown[];
+  onUpdateObject: (dxn: URI.URI, checked: boolean) => Promise<void>;
 };
 
+const emptyObjectsAtom = Atom.make<Obj.Unknown[]>([]);
+
 /**
  * Create reactive map of active object references (by DXN string).
  */
-export const useContextObjects = ({
-  space,
-  context,
-}: {
-  space?: Space;
-  context?: AiContextBinder;
-}): UseContextObjects => {
-  const objects = context?.objects.value.map((ref) => ref.target).filter(isNonNullable) ?? [];
+export const useContextObjects = ({ db, context }: UseContextObjectsProps): UseContextObjects => {
+  const objects = useAtomValue(context?.objects ?? emptyObjectsAtom);
 
   const handleUpdateObject = useCallback<UseContextObjects['onUpdateObject']>(
-    async (dxn: DXN, checked: boolean) => {
-      if (!space || !context) {
-        return;
-      }
-
-      // Load the object by DXN/id from the current space.
-      const id = dxn.asEchoDXN();
-      const object = id && (await space.db.getObjectById(id.echoId));
-      if (!object) {
-        log.warn('Object not found', { dxn, id });
+    async (dxn: URI.URI, checked: boolean) => {
+      if (!db || !context) {
         return;
       }
 
-      const ref = Ref.fromDXN(dxn);
+      const ref = db.makeRef<Obj.Unknown>(dxn);
+      await ref.load();
       if (checked) {
         await context.bind({ objects: [ref] });
       } else {
         await context.unbind({ objects: [ref] });
       }
     },
-    [space, context],
+    [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

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import { useEffect, useState } from 'react';
+
+import { type Database, Type } from '@dxos/echo';
+import { EntityKind, HiddenAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
+
+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.
+export const useFilteredTypes = (db?: Database.Database): Type.AnyEntity[] => {
+  const [types, setTypes] = useState<Type.AnyEntity[]>([]);
+  useEffect(() => {
+    if (!db) {
+      return;
+    }
+
+    setTypes(getFilteredTypes(db));
+    return db.graph.registry.changed.on(() => {
+      setTypes(getFilteredTypes(db));
+    });
+  }, [db]);
+
+  return types;
+};

package/src/hooks/usePresets.ts

@@ -4,7 +4,8 @@
 
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import { type ChatPromptProps } from '../components';
+import { type ChatPromptProps } from '#components';
+
 import { type AiServicePreset, AiServicePresets } from '../processor';
 
 export type UsePresets = {

package/src/hooks/useReferencesProvider.ts

@@ -4,7 +4,6 @@
 
 import { useMemo } from 'react';
 
-import { Capabilities, useCapabilities } from '@dxos/app-framework';
 import { type Space } from '@dxos/client/echo';
 import { Filter, Obj } from '@dxos/echo';
 import { type ReferencesProvider } from '@dxos/react-ui-chat';
@@ -13,8 +12,6 @@ import { type ReferencesProvider } from '@dxos/react-ui-chat';
  * Resolve references to objects in the space.
  */
 export const useReferencesProvider = (space?: Space): ReferencesProvider | undefined => {
-  const blueprints = useCapabilities(Capabilities.BlueprintDefinition);
-
   return useMemo<ReferencesProvider | undefined>((): ReferencesProvider | undefined => {
     if (!space) {
       return undefined;
@@ -24,34 +21,26 @@ export const useReferencesProvider = (space?: Space): ReferencesProvider | undef
       getReferences: async ({ query }) => {
         // TODO(burdon): Previously we filtered by types declared by the artifact definitions.
         // const schemas = blueprints.map((blueprint) => blueprint.schema).flat();
-        // const { objects } = await space.db
+        // const objects = await space.db
         //   .query(Filter.or(...schemas.map((schema) => Filter.type(schema as Type.Schema))))
         //   .run();
 
-        const { objects } = await space.db.query(Filter.everything()).run();
+        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.Any))
-            .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.ids(uri)).first();
+        const object = await space.db.query(Filter.id(uri)).first();
         return { uri, label: Obj.getLabel(object) ?? '' };
       },
     } satisfies ReferencesProvider;
-  }, [space, blueprints]);
+  }, [space]);
 };
 
 const stringMatch = (query: string, label: string) => label.toLowerCase().startsWith(query.toLowerCase());

package/src/index.ts

@@ -2,10 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './capabilities';
-export * from './components';
-export * from './events';
+export * from './blueprints';
 export * from './meta';
 export * from './types';
-
-export * from './AssistantPlugin';

package/src/meta.ts

@@ -2,15 +2,42 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { Plugin } from '@dxos/app-framework';
+import { DXN } from '@dxos/keys';
+import { trim } from '@dxos/util';
 
-export const meta: PluginMeta = {
-  id: 'dxos.org/plugin/assistant',
+export const meta = Plugin.makeMeta({
+  key: DXN.make('org.dxos.plugin.assistant'),
   name: 'Assistant',
-  description: 'The Assistant plugin allows you to chat with your spaces inside of Composer.',
-  icon: 'ph--atom--regular',
+  author: 'DXOS',
+  description: trim`
+    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 = DXN.make(`${meta.id}.assistantDialog`);
 
-export const ASSISTANT_DIALOG = `${meta.id}/assistant/dialog`;
+/** Companion variant identifier for the assistant chat panel. */
+export const ASSISTANT_COMPANION_VARIANT = 'assistant-chat';