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

package/src/hooks/useChatProcessor.ts

@@ -2,25 +2,35 @@
 // Copyright 2025 DXOS.org
 //
 
-import { RegistryContext } from '@effect-rx/rx-react';
-import { type Layer } from 'effect';
-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 { useIntentDispatcher } from '@dxos/app-framework';
-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, ServiceResolver } from '@dxos/compute';
+import { Database, Feed, Ref, Registry } from '@dxos/echo';
+import { createFeedServiceLayer } from '@dxos/echo-client';
+import { EffectEx } from '@dxos/effect';
+import { AgentService } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import { type Queue, type Space, fullyQualifiedId } 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 '../hooks';
-import { type Assistant } from '../types';
+import { type Assistant } from '#types';
+
+import { AiChatProcessor, type AiServicePreset } from '../processor';
 
 export type UseChatProcessorProps = {
   space?: Space;
-  chat?: Assistant.Chat;
+  chat?: Chat.Chat;
   preset?: AiServicePreset;
-  services?: Layer.Layer<AiChatServices>;
-  blueprintRegistry?: Blueprint.Registry;
+  runtime?: Capabilities.ProcessManagerRuntime;
+  registry?: Registry.Registry;
   settings?: Assistant.Settings;
 };
 
@@ -31,51 +41,66 @@ export const useChatProcessor = ({
   space,
   chat,
   preset,
-  services,
-  blueprintRegistry,
+  runtime,
+  registry,
   settings,
 }: UseChatProcessorProps): AiChatProcessor | undefined => {
   const observableRegistry = useContext(RegistryContext);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
 
-  // Tools and context.
-  const chatId = useMemo(() => (chat ? fullyQualifiedId(chat) : undefined), [chat]);
-  const extensions = useMemo(() => ({ space, dispatch, pivotId: chatId }), [dispatch, space, chatId]);
+  const [session, setSession] = useState<AiSession.Session>();
+  useAsyncEffect(async () => {
+    if (!space || !chat) {
+      return;
+    }
 
-  const conversation = useMemo(() => {
-    if (!chat?.queue.target) {
+    const feedTarget = chat.feed.target;
+    if (!feedTarget) {
       return;
     }
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const runtime = await EffectEx.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]);
 
-    return new AiConversation({ queue: chat.queue.target as Queue<any> });
-  }, [chat?.queue.target]);
+  const feed = chat?.feed.target;
+  const serviceResolver = useCapability(Capabilities.ServiceResolver);
 
-  // Create processor.
-  // TODO(burdon): Updated on each query update above; should just update current 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,
+      Registry.Service,
+      OpaqueToolkit.OpaqueToolkitProvider,
+    ).pipe(Layer.provide(Layer.succeed(ServiceResolver.ServiceResolver, serviceResolver)));
 
-    return new AiChatProcessor(services, conversation, {
-      extensions,
-      blueprintRegistry,
+    log('creating processor', { preset, model: preset?.model, settings });
+    return new AiChatProcessor(session, runtime, feed, spaceLayer, {
+      chat: chat ? Ref.make(chat) : undefined,
       observableRegistry,
+      registry,
       model: preset?.model,
     });
-  }, [services, conversation, blueprintRegistry, extensions, preset]);
+  }, [runtime, session, registry, preset, chat, feed, space?.id]);
 
   return processor;
 };
-
-// TODO(dmaretskyi): Extract.
-export const Stable = Object.freeze({
-  array: [] as readonly never[],
-  object: {} as {},
-});

package/src/hooks/useChatServices.ts

@@ -2,71 +2,27 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type AiTool, AiToolkit } from '@effect/ai';
-import { Layer } from 'effect';
-import { useMemo } from 'react';
-
-import { type AiService, type ToolExecutionService, type ToolResolverService } from '@dxos/ai';
-import { Capabilities, useCapabilities } from '@dxos/app-framework';
-import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
-import { type Space } from '@dxos/client/echo';
-import {
-  ComputeEventLogger,
-  CredentialsService,
-  DatabaseService,
-  LocalFunctionExecutionService,
-  QueueService,
-  RemoteFunctionExecutionService,
-  TracingService,
-} from '@dxos/functions';
-
-import { AssistantCapabilities } from '../capabilities';
-
-// TODO(burdon): Deconstruct into separate layers?
-export type AiChatServices =
-  | AiService.AiService
-  | CredentialsService
-  | DatabaseService
-  | QueueService
-  | RemoteFunctionExecutionService
-  | ToolResolverService
-  | ToolExecutionService
-  | TracingService;
+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';
 
 export type UseChatServicesProps = {
-  space?: Space;
+  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}.
  */
-export const useChatServices = ({ space }: UseChatServicesProps): Layer.Layer<AiChatServices> | undefined => {
-  const serviceLayer = useCapabilities(AssistantCapabilities.AiServiceLayer).at(0) ?? Layer.die('AiService not found');
-  const functions = useCapabilities(Capabilities.Functions);
-  const toolkits = useCapabilities(Capabilities.Toolkit);
-  const handlers = useCapabilities(Capabilities.ToolkitHandler);
+export const useChatServices = ({ id }: UseChatServicesProps) => {
+  const client = useClient();
+  id ??= getPersonalSpace(client)?.id;
 
-  return useMemo(() => {
-    const allFunctions = functions.flat();
-    // TODO(wittjosiah): Don't cast.
-    const toolkit = AiToolkit.merge(...toolkits) as AiToolkit.Any as AiToolkit.AiToolkit<AiTool.Any>;
-    const handlersLayer = Layer.mergeAll(Layer.empty, ...handlers);
-    return Layer.mergeAll(
-      serviceLayer,
-      makeToolResolverFromFunctions(allFunctions, toolkit),
-      makeToolExecutionServiceFromFunctions(allFunctions, toolkit, handlersLayer),
-      CredentialsService.layerFromDatabase(),
-      ComputeEventLogger.layerFromTracing,
-    ).pipe(
-      Layer.provideMerge(
-        Layer.mergeAll(
-          space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable,
-          space ? QueueService.layer(space.queues) : QueueService.notAvailable,
-          TracingService.layerNoop,
-          LocalFunctionExecutionService.layer,
-          RemoteFunctionExecutionService.mockLayer,
-        ),
-      ),
-    );
-  }, [space, functions, toolkits, handlers]);
+  const runtime = useCapability(Capabilities.ProcessManagerRuntime);
+  return id ? runtime : undefined;
 };

package/src/hooks/useChatToolbarActions.ts

@@ -0,0 +1,124 @@
+//
+// 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 { EffectEx } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+import { MenuBuilder, useMenuBuilder } from '@dxos/react-ui-menu';
+
+import { meta } from '#meta';
+import { AssistantOperation } from '#types';
+
+import { useChatContext } from '../components/Chat/context';
+
+export type ChatToolbarActionsProps = {
+  chat?: Chat.Chat;
+  companionTo?: Obj.Unknown;
+};
+
+export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsProps) => {
+  const { invoke } = useOperationInvoker();
+  const { db } = useChatContext('useChatToolbarActions');
+
+  // 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),
+        );
+
+      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'));
+
+                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();
+    },
+    [db?.spaceId, companionTo?.id, chat?.id, invoke],
+  );
+};

package/src/hooks/useContextBinder.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Registry, RegistryContext } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import { useContext, useState } from 'react';
+
+import { AiContext } from '@dxos/assistant';
+import { Feed } from '@dxos/echo';
+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,
+): AiContext.Binder | undefined => {
+  const registry = useContext(RegistryContext) as Registry.Registry;
+  const [binder, setBinder] = useState<AiContext.Binder>();
+
+  useAsyncEffect(async () => {
+    setBinder(undefined);
+    if (!space || !feed) {
+      return;
+    }
+
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const runtime = await EffectEx.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

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import { useCallback } from 'react';
+
+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.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 = ({ db, context }: UseContextObjectsProps): UseContextObjects => {
+  const objects = useAtomValue(context?.objects ?? emptyObjectsAtom);
+
+  const handleUpdateObject = useCallback<UseContextObjects['onUpdateObject']>(
+    async (dxn: URI.URI, checked: boolean) => {
+      if (!db || !context) {
+        return;
+      }
+
+      const ref = db.makeRef<Obj.Unknown>(dxn);
+      await ref.load();
+      if (checked) {
+        await context.bind({ objects: [ref] });
+      } else {
+        await context.unbind({ objects: [ref] });
+      }
+    },
+    [db, context],
+  );
+
+  return {
+    objects,
+    onUpdateObject: handleUpdateObject,
+  };
+};

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,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import { useEffect, useState } from 'react';
+
+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.
+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,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 './presets';
+import { type AiServicePreset, AiServicePresets } from '../processor';
 
 export type UsePresets = {
   preset: AiServicePreset | undefined;
-} & Pick<ChatPromptProps, 'presets' | 'onChangePreset'>;
+} & 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 handleChangePreset = useCallback<NonNullable<ChatPromptProps['onChangePreset']>>(
+  const handlePresetChange = useCallback<NonNullable<ChatPresetProps['onPresetChange']>>(
     (id) => {
       const preset = presets.find((preset) => preset.id === id);
       if (preset) {
@@ -40,6 +42,6 @@ export const usePresets = (online: boolean): UsePresets => {
   return {
     preset: preset,
     presets: presetOptions,
-    onChangePreset: handleChangePreset,
+    onPresetChange: handlePresetChange,
   };
 };

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,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './capabilities';
-export * from './components';
-export * from './events';
+export * from './blueprints';
 export * from './meta';
+export * from './paths';
 export * from './types';
-
-export * from './AssistantPlugin';