@dxos/plugin-assistant 0.8.4-main.c85a9c8dae → 0.8.4-main.dfabb4ec29

package/src/hooks/useChatServices.ts

@@ -2,46 +2,25 @@
 // 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/ui';
-import { type Chat } from '@dxos/assistant-toolkit';
+import { getPersonalSpace } from '@dxos/app-toolkit';
 import { type Key } from '@dxos/echo';
-import { TracingService } from '@dxos/functions';
-import { TracingServiceExt } from '@dxos/functions-runtime';
 import { AutomationCapabilities } from '@dxos/plugin-automation';
 import { useClient } from '@dxos/react-client';
 
-import { type AiChatServices } from '../processor';
-
 export type UseChatServicesProps = {
   id?: Key.SpaceId;
-  chat?: Chat.Chat;
 };
 
 /**
- * Construct service layer.
+ * Resolves the compute runtime for a space.
  */
-// TODO(dmaretskyi): Better return type.
-export const useChatServices = ({
-  id,
-  chat,
-}: UseChatServicesProps): (() => Promise<Runtime.Runtime<AiChatServices>>) | undefined => {
+export const useChatServices = ({ id }: UseChatServicesProps) => {
   const client = useClient();
-  id ??= client.spaces.default.id;
+  id ??= getPersonalSpace(client)?.id;
 
   const runtimeResolver = useCapability(AutomationCapabilities.ComputeRuntime);
-  return useMemo(() => {
-    const runtime = runtimeResolver.getRuntime(id);
-    return () =>
-      runtime.runPromise(
-        Effect.runtime<AiChatServices>().pipe(
-          Effect.provide(
-            chat?.traceQueue?.target ? TracingServiceExt.layerQueue(chat.traceQueue?.target) : TracingService.layerNoop,
-          ),
-        ),
-      );
-  }, [id, chat?.traceQueue?.target]);
+  return useMemo(() => (!id ? undefined : runtimeResolver.getRuntime(id)), [id]);
 };

package/src/hooks/useChatToolbarActions.ts

@@ -14,9 +14,9 @@ import { invariant } from '@dxos/invariant';
 import { useQuery } from '@dxos/react-client/echo';
 import { MenuBuilder, useMenuActions } from '@dxos/react-ui-menu';
 
-import { useChatContext } from '../components';
-import { meta } from '../meta';
-import { AssistantOperation } from '../types';
+import { useChatContext } from '#components';
+import { meta } from '#meta';
+import { AssistantOperation } from '#types';
 
 export type ChatToolbarActionsProps = {
   chat?: Chat.Chat;
@@ -39,12 +39,12 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
       return Atom.make(() => {
         const builder = MenuBuilder.make()
           .root({
-            label: ['chat toolbar title', { ns: meta.id }],
+            label: ['chat-toolbar.title', { ns: meta.id }],
           })
           .action(
             'new',
             {
-              label: ['new thread button', { ns: meta.id }],
+              label: ['new-thread.button', { ns: meta.id }],
               icon: 'ph--plus--regular',
               type: 'new',
               disabled: !companionTo,
@@ -60,7 +60,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
           .action(
             'rename',
             {
-              label: ['rename thread button', { ns: meta.id }],
+              label: ['rename-thread.button', { ns: meta.id }],
               icon: 'ph--magic-wand--regular',
               type: 'rename',
               disabled: !chat,
@@ -74,7 +74,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
           .action(
             'branch',
             {
-              label: ['button branch thread', { ns: meta.id }],
+              label: ['branch-thread.menu', { ns: meta.id }],
               icon: 'ph--git-branch--regular',
               type: 'branch',
               disabled: true,
@@ -86,7 +86,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
           builder.group(
             'chats',
             {
-              label: ['chat history label', { ns: meta.id }],
+              label: ['chat-history.label', { ns: meta.id }],
               icon: 'ph--clock-counter-clockwise--regular',
               selectCardinality: 'single',
               variant: 'dropdownMenu',
@@ -99,7 +99,7 @@ export const useChatToolbarActions = ({ chat, companionTo }: ChatToolbarActionsP
                   builder.action(
                     chat.id,
                     {
-                      label: Obj.getLabel(chat) ?? ['object name placeholder', { ns: Chat.Chat.typename }],
+                      label: Obj.getLabel(chat) ?? ['object-name.placeholder', { ns: Chat.Chat.typename }],
                     },
                     () =>
                       Effect.gen(function* () {

package/src/hooks/useContextBinder.ts

@@ -3,30 +3,41 @@
 //
 
 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 { type Queue } from '@dxos/react-client/echo';
+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';
 
-// NOTE: This takes a queue rather than a chat because the chat may not be in a space yet.
-export const useContextBinder = (queue: Queue | undefined): AiContextBinder | undefined => {
+export const useContextBinder = (
+  space: Space | undefined,
+  feed: Feed.Feed | undefined,
+): AiContextBinder | undefined => {
   const registry = useContext(RegistryContext) as Registry.Registry;
   const [binder, setBinder] = useState<AiContextBinder>();
 
   useAsyncEffect(async () => {
-    if (!queue) {
+    setBinder(undefined);
+    if (!space || !feed) {
       return;
     }
 
-    const binder = new AiContextBinder({ queue, registry });
+    const feedServiceLayer = createFeedServiceLayer(space.queues);
+    const runtime = await runAndForwardErrors(
+      Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
+    );
+    const binder = new AiContextBinder({ feed, runtime, registry });
     await binder.open();
     setBinder(binder);
 
     return () => {
       void binder.close();
     };
-  }, [queue]);
+  }, [space, feed]);
 
   return binder;
 };

package/src/hooks/useContextObjects.ts

@@ -2,10 +2,11 @@
 // 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 Database, type Obj, Ref } from '@dxos/echo';
+import { type DXN, type Database, type Obj } from '@dxos/echo';
 
 export type UseContextObjectsProps = {
   db?: Database.Database;
@@ -17,18 +18,21 @@ export type UseContextObjects = {
   onUpdateObject: (dxn: DXN, 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: DXN, checked: boolean) => {
       if (!db || !context) {
         return;
       }
 
-      // Load the object by DXN from the current space.
-      const ref = Ref.fromDXN(dxn);
+      const ref = db.makeRef<Obj.Unknown>(dxn);
       await ref.load();
       if (checked) {
         await context.bind({ objects: [ref] });
@@ -40,7 +44,7 @@ export const useContextObjects = ({ db, context }: UseContextObjectsProps): UseC
   );
 
   return {
-    objects: context?.getObjects() ?? [],
+    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

@@ -23,7 +23,7 @@ export const useFilteredTypes = (db?: Database.Database): Type.AnyEntity[] => {
           new Set(
             query.results
               .filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation)
-              .filter((schema) => SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))),
+              .filter((schema) => !SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))),
           ),
         );
 

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/index.ts

@@ -3,11 +3,5 @@
 //
 
 export * from './blueprints';
-export * from './capabilities';
-export * from './components';
-export * from './hooks';
 export * from './meta';
-export * from './translations';
 export * from './types';
-
-export * from './AssistantPlugin';

package/src/meta.ts

@@ -6,16 +6,19 @@ import { type Plugin } from '@dxos/app-framework';
 import { trim } from '@dxos/util';
 
 export const meta: Plugin.Meta = {
-  id: 'dxos.org/plugin/assistant',
+  id: 'org.dxos.plugin.assistant',
   name: 'Assistant',
   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.
   `,
-  icon: 'ph--atom--regular',
+  icon: 'ph--sparkle--regular',
   iconHue: 'sky',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-assistant',
   tags: ['labs'],
 };
 
-export const ASSISTANT_DIALOG = `${meta.id}/assistant/dialog`;
+export const ASSISTANT_DIALOG = `${meta.id}.assistant.dialog`;
+
+/** Companion variant identifier for the assistant chat panel. */
+export const ASSISTANT_COMPANION_VARIANT = 'assistant-chat';

package/src/operations/create-chat.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AiContextBinder } from '@dxos/assistant';
+import { Chat, DatabaseBlueprint, AgentWizardBlueprint } from '@dxos/assistant-toolkit';
+import { Blueprint, Operation } from '@dxos/compute';
+import { Feed, Filter, Obj, Ref } from '@dxos/echo';
+import { createFeedServiceLayer } from '@dxos/echo-db';
+import { invariant } from '@dxos/invariant';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { AssistantBlueprint } from '#blueprints';
+import { AssistantOperation } from '#types';
+
+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);
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      const space = client.spaces.get(db.spaceId);
+      invariant(space, 'Space not found');
+      const feed = space.db.add(Feed.make());
+      const chat = Chat.make({ name, feed: Ref.make(feed) });
+      Obj.setParent(feed, chat);
+      if (addToSpace) {
+        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 });
+      yield* Effect.promise(() =>
+        binder.use((b: AiContextBinder) =>
+          b.bind({
+            blueprints: [
+              Ref.make(defaultAssistantBlueprint!),
+              Ref.make(defaultDatabaseBlueprint!),
+              Ref.make(defaultAgentWizardBlueprint!),
+              Ref.make(defaultBlueprintManagerBlueprint!),
+            ],
+          }),
+        ),
+      );
+
+      return { object: chat };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/ensure-companion-chat.ts

@@ -0,0 +1,63 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Operation } from '@dxos/compute';
+import { Filter, Obj, Query } from '@dxos/echo';
+
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+const handler: Operation.WithHandler<typeof AssistantOperation.EnsureCompanionChat> =
+  AssistantOperation.EnsureCompanionChat.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* ({ db, companionTo }) {
+        const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
+        const companionDxn = Obj.getDXN(companionTo).toString();
+
+        // 1. Look for an existing persisted companion chat in the space.
+        const existingChats = yield* Effect.promise(() =>
+          db.query(Query.select(Filter.id(companionTo.id)).targetOf(Chat.CompanionTo).source()).run(),
+        );
+        if (existingChats.length > 0) {
+          const chat = existingChats.at(-1) as Chat.Chat;
+          // Cache the persisted chat so the graph connector can resolve it immediately
+          // via the cache fallback, without waiting for AtomObj.make(ref) to hydrate.
+          yield* Capabilities.updateAtomValue(AssistantCapabilities.CompanionChatCache, (current) => ({
+            ...current,
+            [companionDxn]: chat,
+          }));
+          yield* Effect.promise(() =>
+            operationInvoker.invokePromise(AssistantOperation.SetCurrentChat, { companionTo, chat }),
+          );
+          return { chat, persisted: true };
+        }
+
+        // 2. Return cached transient chat for this companion if present.
+        const cache = yield* Capabilities.getAtomValue(AssistantCapabilities.CompanionChatCache);
+        const cached = cache[companionDxn] as Chat.Chat | undefined;
+        if (cached) {
+          return { chat: cached, persisted: false };
+        }
+
+        // 3. Create a new transient chat, cache it, and return it without persisting.
+        const { data } = yield* Effect.promise(() =>
+          operationInvoker.invokePromise(AssistantOperation.CreateChat, { db, addToSpace: false }),
+        );
+        if (!data?.object) {
+          return yield* Effect.fail(new Error('CreateChat did not return a chat object'));
+        }
+        const chat = data.object;
+        yield* Capabilities.updateAtomValue(AssistantCapabilities.CompanionChatCache, (current) => ({
+          ...current,
+          [companionDxn]: chat,
+        }));
+        return { chat, persisted: false };
+      }),
+    ),
+  );
+
+export default handler;

package/src/operations/index.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const AssistantOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./create-chat'),
+  () => import('./ensure-companion-chat'),
+  () => import('./on-create-space'),
+  () => import('./resolve-navigation-targets'),
+  () => import('./run-prompt-in-new-chat'),
+  () => import('./set-current-chat'),
+  () => import('./update-chat-name'),
+);

package/src/operations/on-create-space.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { AssistantOperation } from '#types';
+
+const handler: Operation.WithHandler<typeof AssistantOperation.OnCreateSpace> = AssistantOperation.OnCreateSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ space }) {
+      // TODO(wittjosiah): Remove once function registry is avaiable.
+      space.db.add(Operation.serialize(AgentPrompt));
+
+      const { object: chat } = yield* Operation.invoke(AssistantOperation.CreateChat, { db: space.db });
+      space.db.add(chat);
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/prompt.test.ts

@@ -0,0 +1,77 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Array from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import { describe, test } from 'vitest';
+
+import { AgentPrompt, Chat } from '@dxos/assistant-toolkit';
+import { Routine, Operation } from '@dxos/compute';
+import { Database, Feed, Filter, Ref } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
+import { ObjectId } from '@dxos/keys';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { AutomationPlugin } from '@dxos/plugin-automation/plugin';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { ClientPlugin } from '@dxos/plugin-client/plugin';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { createComposerTestApp } from '@dxos/plugin-testing/harness';
+import { Message } from '@dxos/types';
+
+import { AssistantPlugin } from '#plugin';
+
+ObjectId.dangerouslyDisableRandomness();
+
+describe('Agent prompt (composer plugin harness)', () => {
+  // Hits AutomationPlugin compute runtime (plugin handlers, AiServiceLayer, blueprints).
+  // Requires reachable edge AI (see repo DX_EDGE_AI_SERVICE_URL); not memoized like AssistantTestLayer tests.
+  test(
+    'chat mode appends assistant messages to the chat queue',
+    { tags: ['llm'], timeout: 60_000 },
+    async ({ expect }) => {
+      await using harness = await createComposerTestApp({
+        plugins: [ClientPlugin({}), AssistantPlugin(), AutomationPlugin()],
+      });
+
+      const { personalSpace } = await runAndForwardErrors(initializeIdentity(harness.get(ClientCapabilities.Client)));
+      const computeProvider = await harness.waitForCapability(AutomationCapabilities.ComputeRuntime, {
+        timeout: 30_000,
+      });
+
+      await computeProvider.getRuntime(personalSpace.id).runPromise(
+        Effect.gen(function* () {
+          const feed = yield* Database.add(Feed.make());
+
+          const messageCountBefore = yield* Feed.runQuery(feed, Filter.type(Message.Message)).pipe(
+            Effect.map(Array.length),
+          );
+
+          const chat = yield* Database.add(Chat.make({ feed: Ref.make(feed) }));
+          const prompt = yield* Database.add(
+            Routine.make({
+              name: 'chat-mode-test',
+              instructions: 'Reply with a single word: ack.',
+              blueprints: [],
+              context: [],
+            }),
+          );
+          yield* Database.flush();
+
+          const result = yield* Operation.invoke(AgentPrompt, {
+            prompt: Ref.make(prompt),
+            input: {},
+            chat: Ref.make(chat),
+          });
+
+          const messageCountAfter = yield* Feed.runQuery(feed, Filter.type(Message.Message)).pipe(
+            Effect.map(Array.length),
+          );
+
+          expect(messageCountAfter).toBeGreaterThan(messageCountBefore);
+          expect(result).toBe('ack');
+        }),
+      );
+    },
+  );
+});

package/src/operations/resolve-navigation-targets.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { AssistantOperation } from '#types';
+
+export default AssistantOperation.ResolveNavigationTargets.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ query }) {
+      const capabilities = yield* Capability.Service;
+
+      // Delegate to contributed resolvers.
+      const resolvers = capabilities.getAll(AppCapabilities.NavigationTargetResolver);
+      const results = yield* Effect.forEach(resolvers, (resolver) =>
+        resolver(query as AppCapabilities.NavigationQuery).pipe(Effect.catchAll(() => Effect.succeed([]))),
+      );
+      return { targets: results.flat() };
+    }),
+  ),
+);