@dxos/plugin-assistant 0.8.4-main.abd8ff62ef → 0.8.4-main.bc2380dfbc

package/src/operations/run-prompt-in-new-chat.ts

@@ -6,107 +6,108 @@ import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { getObjectPathFromObject, LayoutOperation } from '@dxos/app-toolkit';
-import { AiContextBinder } from '@dxos/assistant';
+import { AiContext } from '@dxos/assistant';
 import { AgentPrompt } from '@dxos/assistant-toolkit';
 import { Blueprint, Routine, Template, Operation } from '@dxos/compute';
 import { Database, Feed, Filter, Obj, Ref } from '@dxos/echo';
 import { createFeedServiceLayer } from '@dxos/echo-db';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { Text } from '@dxos/schema';
 
-import { AssistantCapabilities } from '../types';
-import { CreateChat, RunPromptInNewChat } from './definitions';
+import { AssistantCapabilities, AssistantOperation } from '#types';
 
-const handler: Operation.WithHandler<typeof RunPromptInNewChat> = RunPromptInNewChat.pipe(
-  Operation.withHandler(
-    Effect.fnUntraced(
-      function* ({ db, prompt, objects, blueprints, background }) {
-        const registry = yield* Capability.get(Capabilities.AtomRegistry);
-        const { object: chat } = yield* Operation.invoke(CreateChat, { db });
+const handler: Operation.WithHandler<typeof AssistantOperation.RunPromptInNewChat> =
+  AssistantOperation.RunPromptInNewChat.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(
+        function* ({ db, prompt, objects, blueprints, background }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const { object: chat } = yield* Operation.invoke(AssistantOperation.CreateChat, { db });
 
-        if ((objects && objects.length > 0) || (blueprints && blueprints.length > 0)) {
-          const feedTarget = chat.feed.target;
-          invariant(feedTarget, 'Chat feed not found.');
-          const client = yield* Capability.get(ClientCapabilities.Client);
-          const space = client.spaces.get(db.spaceId);
-          invariant(space, 'Space not found.');
-          const feedServiceLayer = createFeedServiceLayer(space.queues);
-          const runtime = yield* Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer));
-          const binder = new AiContextBinder({ feed: feedTarget, runtime, registry });
-          yield* Effect.promise(() =>
-            binder.use(async (b: AiContextBinder) => {
-              const bindingProps: Parameters<AiContextBinder['bind']>[0] = {};
+          if ((objects && objects.length > 0) || (blueprints && blueprints.length > 0)) {
+            const feedTarget = chat.feed.target;
+            invariant(feedTarget, 'Chat feed not found.');
+            const client = yield* Capability.get(ClientCapabilities.Client);
+            const space = client.spaces.get(db.spaceId);
+            invariant(space, 'Space not found.');
+            const feedServiceLayer = createFeedServiceLayer(space.queues);
+            const runtime = yield* Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer));
+            const binder = new AiContext.Binder({ feed: feedTarget, runtime, registry });
+            yield* Effect.promise(() =>
+              binder.use(async (b: AiContext.Binder) => {
+                const bindingProps: Parameters<AiContext.Binder['bind']>[0] = {};
 
-              if (objects && objects.length > 0) {
-                bindingProps.objects = objects.map((obj) => Ref.make(obj));
-              }
+                if (objects && objects.length > 0) {
+                  bindingProps.objects = objects.map((obj) => Ref.make(obj));
+                }
 
-              if (blueprints && blueprints.length > 0) {
-                const allBlueprints = await db.query(Filter.type(Blueprint.Blueprint)).run();
-                const matchedBlueprints = allBlueprints.filter(
-                  (blueprint) => blueprint.key && blueprints.includes(blueprint.key),
-                );
-                if (matchedBlueprints.length > 0) {
-                  bindingProps.blueprints = matchedBlueprints.map((blueprint) => Ref.make(blueprint));
+                if (blueprints && blueprints.length > 0) {
+                  const allBlueprints = await db.query(Filter.type(Blueprint.Blueprint)).run();
+                  const matchedBlueprints = allBlueprints.filter((blueprint) => {
+                    const blueprintKey = Obj.getMeta(blueprint).key;
+                    return blueprintKey !== undefined && blueprints.includes(blueprintKey);
+                  });
+                  if (matchedBlueprints.length > 0) {
+                    bindingProps.blueprints = matchedBlueprints.map((blueprint) => Ref.make(blueprint));
+                  }
                 }
-              }
 
-              await b.bind(bindingProps);
-            }),
-          );
-        }
+                await b.bind(bindingProps);
+              }),
+            );
+          }
+
+          if (background) {
+            const promptRef =
+              typeof prompt === 'string'
+                ? Ref.make(
+                    Routine.make({
+                      instructions: prompt,
+                      blueprints: [],
+                      context: [],
+                    }),
+                  )
+                : prompt;
+            yield* Database.flush();
+            const computeRuntime = yield* Capability.get(AutomationCapabilities.ComputeRuntime);
+            const runtime = yield* computeRuntime.getRuntime(db.spaceId).runtimeEffect;
+            yield* Operation.invoke(AgentPrompt, {
+              prompt: promptRef,
+              input: {},
+              chat: Ref.make(chat),
+            }).pipe(
+              Effect.provide(runtime),
+              Effect.catchAll((error) => {
+                log.catch(error);
+                return Effect.void;
+              }),
+            );
+            return { object: chat };
+          }
 
-        if (background) {
-          const promptRef =
+          const chatPath = getObjectPathFromObject(chat);
+          const pendingPromptText =
             typeof prompt === 'string'
-              ? Ref.make(
-                  Routine.make({
-                    instructions: prompt,
-                    blueprints: [],
-                    context: [],
-                  }),
-                )
-              : prompt;
-          yield* Database.flush();
-          const computeRuntime = yield* Capability.get(AutomationCapabilities.ComputeRuntime);
-          const runtime = yield* computeRuntime.getRuntime(db.spaceId).runtimeEffect;
-          yield* Operation.invoke(AgentPrompt, {
-            prompt: promptRef,
-            input: {},
-            chat: Ref.make(chat),
-          }).pipe(
-            Effect.provide(runtime),
-            Effect.catchAll((error) => {
-              log.catch(error);
-              return Effect.void;
-            }),
-          );
+              ? prompt
+              : yield* Effect.gen(function* () {
+                  const promptObj = yield* Effect.promise(() => prompt.load());
+                  const source = yield* Effect.promise(() => promptObj.instructions.source.load());
+                  invariant(Obj.instanceOf(Text.Text, source), 'Prompt template source must be Text.');
+                  return Template.process(source.content ?? '');
+                });
+          yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
+            ...current,
+            pendingPrompts: { ...current.pendingPrompts, [chatPath]: pendingPromptText },
+          }));
+          yield* Operation.invoke(LayoutOperation.Open, { subject: [chatPath] });
           return { object: chat };
-        }
-
-        const chatPath = getObjectPathFromObject(chat);
-        const pendingPromptText =
-          typeof prompt === 'string'
-            ? prompt
-            : yield* Effect.gen(function* () {
-                const promptObj = yield* Effect.promise(() => prompt.load());
-                const source = yield* Effect.promise(() => promptObj.instructions.source.load());
-                invariant(Obj.instanceOf(Text.Text, source), 'Prompt template source must be Text.');
-                return Template.process(source.content ?? '');
-              });
-        yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
-          ...current,
-          pendingPrompts: { ...current.pendingPrompts, [chatPath]: pendingPromptText },
-        }));
-        yield* Operation.invoke(LayoutOperation.Open, { subject: [chatPath] });
-        return { object: chat };
-      },
-      (effect, { db }) => effect.pipe(Effect.provide(Database.layer(db))),
+        },
+        (effect, { db }) => effect.pipe(Effect.provide(Database.layer(db))),
+      ),
     ),
-  ),
-);
+  );
 
 export default handler;

package/src/operations/set-current-chat.ts

@@ -8,10 +8,9 @@ import { Capabilities, Capability } from '@dxos/app-framework';
 import { Operation } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
 
-import { AssistantCapabilities } from '../types';
-import { CreateChat, SetCurrentChat } from './definitions';
+import { AssistantCapabilities, AssistantOperation } from '#types';
 
-const handler: Operation.WithHandler<typeof SetCurrentChat> = SetCurrentChat.pipe(
+const handler: Operation.WithHandler<typeof AssistantOperation.SetCurrentChat> = AssistantOperation.SetCurrentChat.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ companionTo, chat }) {
       const companionToId = Obj.getDXN(companionTo).toString();
@@ -29,7 +28,7 @@ const handler: Operation.WithHandler<typeof SetCurrentChat> = SetCurrentChat.pip
         const db = Obj.getDatabase(companionTo);
         if (db) {
           const { data } = yield* Effect.promise(() =>
-            operationInvoker.invokePromise(CreateChat, { db, addToSpace: false }),
+            operationInvoker.invokePromise(AssistantOperation.CreateChat, { db, addToSpace: false }),
           );
           if (data?.object) {
             yield* Capabilities.updateAtomValue(AssistantCapabilities.CompanionChatCache, (current) => ({

package/src/operations/toggle-trace-panel-debug.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+const handler: Operation.WithHandler<typeof AssistantOperation.ToggleTracePanelDebug> =
+  AssistantOperation.ToggleTracePanelDebug.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* (input) {
+        const current = yield* Capabilities.getAtomValue(AssistantCapabilities.Settings);
+        const next = input.state ?? !current.tracePanelDebug;
+        yield* Capabilities.updateAtomValue(AssistantCapabilities.Settings, (settings) => ({
+          ...settings,
+          tracePanelDebug: next,
+        }));
+        return next;
+      }),
+    ),
+  );
+
+export default handler;

package/src/operations/update-chat-name.ts

@@ -13,9 +13,9 @@ import { log } from '@dxos/log';
 import { Message } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { UpdateChatName } from './definitions';
+import { AssistantOperation } from '#types';
 
-const handler: Operation.WithHandler<typeof UpdateChatName> = UpdateChatName.pipe(
+const handler: Operation.WithHandler<typeof AssistantOperation.UpdateChatName> = AssistantOperation.UpdateChatName.pipe(
   Operation.withHandler(
     Effect.fnUntraced(
       function* ({ chat }) {

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const AssistantPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { AssistantOperationHandlerSet } from './operations';

package/src/processor/processor.test.ts

@@ -25,7 +25,7 @@ describe('Chat processor', () => {
         const feed = Feed.make();
         yield* Database.add(feed);
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const session = yield* acquireReleaseResource(() => new AiSession({ feed, runtime }));
+        const session = yield* acquireReleaseResource(() => new AiSession.Session({ feed, runtime }));
         const managedRuntime = ManagedRuntime.make(
           Effect.runSync(Effect.map(Effect.context<never>(), () => undefined as any)) as any,
         );

package/src/processor/processor.ts

@@ -10,8 +10,8 @@ import * as Stream from 'effect/Stream';
 
 import { type AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry } from '@dxos/ai';
 import {
-  AiContextService,
-  type AiSession,
+  AiContext,
+  AiSession,
   createSystemPrompt,
   formatSystemPrompt,
   McpServerError,
@@ -25,10 +25,10 @@ import { runAndForwardErrors, unwrapExit } from '@dxos/effect';
 import { type QueueService } from '@dxos/functions';
 import { AgentService } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
-import type { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { type AutomationCapabilities } from '@dxos/plugin-automation';
 import { Message } from '@dxos/types';
 
-import { UpdateChatName } from '../operations/definitions';
+import { AssistantOperation } from '#types';
 
 /**
  * @deprecated Services type for the old direct-conversation processor path.
@@ -64,11 +64,11 @@ const defaultOptions: Partial<AiChatProcessorOptions> = {
   autoUpdateNameChance: 0.1,
 };
 
-export type AiRequestOptions = {};
+export type ProcessorRequestOptions = {};
 
-export type AiRequest = {
+export type ProcessorRequest = {
   message: string;
-  options?: AiRequestOptions;
+  options?: ProcessorRequestOptions;
 };
 
 /**
@@ -91,7 +91,7 @@ export class AiChatProcessor {
   #requestFiber: Fiber.RuntimeFiber<void, unknown> | undefined;
 
   /** Last request (for retries). */
-  #lastRequest: AiRequest | undefined;
+  #lastRequest: ProcessorRequest | undefined;
 
   /** Streaming state. */
   public readonly streaming = Atom.make<boolean>((get) => get(this.#streaming).length > 0);
@@ -113,7 +113,7 @@ export class AiChatProcessor {
   public readonly mcpErrors = Atom.make<readonly Trace.PayloadType<typeof McpServerError>[]>([]);
 
   constructor(
-    private readonly _conversation: AiSession,
+    private readonly _conversation: AiSession.Session,
     private readonly _runtime: AutomationCapabilities.ComputeRuntime,
     private readonly _feed: Feed.Feed,
     private readonly _options: AiChatProcessorOptions = defaultOptions,
@@ -151,14 +151,14 @@ export class AiChatProcessor {
         const blueprints = this.context.getBlueprints();
         const objects = this.context.getObjects();
         return yield* formatSystemPrompt({ system: this._options.system, blueprints, objects });
-      }).pipe(Effect.provideService(AiContextService, { binder: this.context }), Effect.orDie),
+      }).pipe(Effect.provideService(AiContext.Service, { binder: this.context }), Effect.orDie),
     );
   }
 
   /**
    * Initiates a new request via AgentService.
    */
-  async request(requestProp: AiRequest): Promise<void> {
+  async request(requestProp: ProcessorRequest): Promise<void> {
     if (this.#requestFiber) {
       await this.cancel();
     }
@@ -260,7 +260,7 @@ export class AiChatProcessor {
    * Update the current chat's name.
    */
   async updateName(chat: Chat.Chat): Promise<void> {
-    unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(UpdateChatName, { chat })));
+    unwrapExit(await this._runtime.runPromiseExit(Operation.invoke(AssistantOperation.UpdateChatName, { chat })));
   }
 
   /**
@@ -304,13 +304,13 @@ export class AiChatProcessor {
   }
 
   /**
-   * Records a per-server MCP failure, deduped by url+kind so repeat misconfigurations
+   * Records a per-server MCP failure, deduped by url+protocol so repeat misconfigurations
    * across turns do not spam the UI.
    */
   #handleMcpError(event: Trace.PayloadType<typeof McpServerError>) {
     log.warn('MCP server error', event);
     this.#registry.update(this.mcpErrors, (errors) => {
-      if (errors.some((existing) => existing.url === event.url && existing.kind === event.kind)) {
+      if (errors.some((existing) => existing.url === event.url && existing.protocol === event.protocol)) {
         return errors;
       }
       return [...errors, event];
@@ -347,6 +347,6 @@ export class AiChatProcessor {
 
     // TODO(dmaretskyi): Operation.schedule didn't work.
     log.info('scheduling chat name update', { hasName: !!chat.name, chance });
-    return Operation.schedule(UpdateChatName, { chat });
+    return Operation.schedule(AssistantOperation.UpdateChatName, { chat });
   }
 }

package/src/testing/test-generator.test.ts

@@ -2,80 +2,69 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import { describe, test } from 'vitest';
 
-import { Database } from '@dxos/echo';
+import { Database, Feed, Obj } from '@dxos/echo';
 import { runAndForwardErrors } from '@dxos/effect';
-import { ContextQueueService } from '@dxos/functions';
-import { DXN, ObjectId, SpaceId } from '@dxos/keys';
-import { type Queue } from '@dxos/react-client/echo';
 import { type Message } from '@dxos/types';
 
 import { createMessageGenerator } from './test-generator';
 
-class RecordingQueue implements Queue<Message.Message> {
-  readonly dxn = new DXN(DXN.kind.QUEUE, [SpaceId.random(), ObjectId.random()]);
-  readonly #subscribers = new Set<() => void>();
-
-  objects: Message.Message[] = [];
-  isLoading = false;
-  error = null;
-
-  declare query: Queue<Message.Message>['query'];
-
-  subscribe(callback: () => void) {
-    this.#subscribers.add(callback);
-    return () => this.#subscribers.delete(callback);
-  }
-
-  async append(objects: Message.Message[]) {
-    this.objects = [...this.objects, ...objects];
-    this.#emit();
-  }
-
-  async delete(ids: string[]) {
-    this.objects = this.objects.filter((object) => !ids.includes(object.id));
-    this.#emit();
-  }
-
-  async sync() {}
-
-  async queryObjects() {
-    return this.objects;
-  }
-
-  async getObjectsById(ids: ObjectId[]) {
-    return ids.map((id) => this.objects.find((object) => object.id === id));
-  }
-
-  async refresh() {}
-
-  #emit() {
-    for (const subscriber of this.#subscribers) {
-      subscriber();
-    }
-  }
-}
+/**
+ * In-memory FeedService that records appends and emits a change event whenever
+ * `append` is called. Used to verify the streaming-message generator emits
+ * per-chunk updates.
+ */
+const makeRecordingFeedLayer = () => {
+  const items: Message.Message[] = [];
+  const subscribers = new Set<() => void>();
+
+  const feedService: Context.Tag.Service<Feed.FeedService> = {
+    append: async (_feed: Feed.Feed, newItems) => {
+      items.push(...(newItems as Message.Message[]));
+      for (const fn of subscribers) {
+        fn();
+      }
+    },
+    remove: async () => {},
+    query: () =>
+      ({
+        subscribe: () => () => {},
+        results: [],
+        run: async () => [],
+      }) as any,
+    sync: async () => {},
+  };
+
+  return {
+    items,
+    onAppend: (cb: () => void) => subscribers.add(cb),
+    layer: Layer.succeed(Feed.FeedService, feedService),
+  };
+};
 
 describe('createMessageGenerator', () => {
   test('streaming message publishes updates for chunk mutations', async ({ expect }) => {
-    const queue = new RecordingQueue();
+    const recording = makeRecordingFeedLayer();
     let updates = 0;
-    queue.subscribe(() => updates++);
+    recording.onAppend(() => updates++);
+
+    const feed = Obj.make(Feed.Feed, { name: 'recording' });
 
     // The streaming step is the third entry (index 2) — earlier indices are the initial
     // user prompt and an assistant message with an Organization link (which requires
     // `Database.Service`, unavailable in this unit-test layer).
     await runAndForwardErrors(
       createMessageGenerator()[2]!.pipe(
-        Effect.provide(Layer.mergeAll(ContextQueueService.layer(queue), Database.notAvailable)),
+        Effect.provide(Layer.mergeAll(Feed.ContextFeedService.layer(feed), recording.layer, Database.notAvailable)),
       ),
     );
 
-    expect(queue.objects).toHaveLength(1);
+    expect(recording.items).toHaveLength(1);
     expect(updates).toBeGreaterThan(1);
-    expect(queue.objects[0].blocks[0]).toMatchObject({ pending: false });
+    expect(recording.items[0].blocks[0]).toMatchObject({ pending: false });
   });
 });