@dxos/plugin-assistant 0.8.4-main.422d1c7879 → 0.8.4-main.43cb759274

package/src/testing/index.ts

@@ -5,3 +5,5 @@
 export * from './test-generator';
 export * from './test-sequence';
 export * from './test-services';
+export * from './test-trace';
+export * from './snapshot';

package/src/testing/snapshot.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import type { Client } from '@dxos/client';
+
+/**
+ * Initializes a client from a space snapshot.
+ * Creates and identity and imports a space from a snapshot.
+ *
+ * To be used with `onClientInitialized` in `ClientPlugin`.
+ *
+ * @example
+ * ```ts
+ * ClientPlugin({
+ *   onClientInitialized: initClientFromSpaceSnapshot(() => import('../../testing/data/trace-timeline.dx.json')),
+ * }),
+ * ```
+ */
+export const initClientFromSpaceSnapshot: {
+  (loadSnapshotJson: () => Promise<unknown>): (opts: { client: Client }) => Effect.Effect<void>;
+} =
+  (loadSnapshotJson) =>
+  ({ client }) =>
+    Effect.promise(async () => {
+      await client.halo.createIdentity();
+      const data = await loadSnapshotJson();
+      const space = await client.spaces.import({
+        filename: 'snapshot.dx.json',
+        contents: new TextEncoder().encode(JSON.stringify(data)),
+      });
+      await space.db.flush();
+    });

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

@@ -2,80 +2,70 @@
 // 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 () => {},
+    getSyncState: async () => ({ blocksToPull: 0, blocksToPush: 0, totalBlocks: 0 }),
+  };
+
+  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 });
   });
 });

package/src/testing/test-generator.ts

@@ -4,12 +4,10 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Obj } from '@dxos/echo';
-import { Database } from '@dxos/echo';
+import { Database, Feed, Obj } from '@dxos/echo';
 import { type Mutable } from '@dxos/echo/internal';
-import { ContextQueueService } from '@dxos/functions';
 import { random } from '@dxos/random';
-import { renderObjectLink, textStream } from '@dxos/react-ui-components';
+import { renderObjectLink, textStream } from '@dxos/react-ui-markdown';
 import { type Actor, type ContentBlock, Message, Organization } from '@dxos/types';
 import { trim } from '@dxos/util';
 
@@ -21,25 +19,27 @@ export const createMessage = (role: Actor.Role, blocks: ContentBlock.Any[]): Mes
   });
 };
 
-export type MessageGenerator = Effect.Effect<void, never, Database.Service | ContextQueueService>;
+export type MessageGenerator = Effect.Effect<
+  void,
+  never,
+  Database.Service | Feed.ContextFeedService | Feed.FeedService
+>;
 
 export const createMessageGenerator = (): MessageGenerator[] => [
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('user', [
-          {
-            _tag: 'text',
-            text: random.lorem.sentence(5),
-          },
-        ]),
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('user', [
+        {
+          _tag: 'text',
+          text: random.lorem.sentence(5),
+        },
       ]),
-    );
+    ]);
   }),
 
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
+    const { feed } = yield* Feed.ContextFeedService;
     const { db } = yield* Database.Service;
     const obj1 = db.add(
       Obj.make(Organization.Organization, {
@@ -51,67 +51,65 @@ export const createMessageGenerator = (): MessageGenerator[] => [
     // const obj2 = db.add(Obj.make(Person.Person, { fullName: 'Alice' }));
     // const obj3 = db.add(Obj.make(Person.Person, { fullName: 'Bob' }));
     // const obj4 = db.add(Obj.make(Person.Person, { fullName: 'Charlie' }));
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          // Inline tag.
-          {
-            _tag: 'text',
-            text: [random.lorem.paragraph(), renderObjectLink(obj1), random.lorem.paragraph(), '\n'].join(' '),
-          },
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        // Inline tag.
+        {
+          _tag: 'text',
+          text: [random.lorem.paragraph(), renderObjectLink(obj1), random.lorem.paragraph(), '\n'].join(' '),
+        },
 
-          // Inline cards.
-          // ...[obj1, obj2, obj3, obj4].map(
-          //   (obj) =>
-          //     ({
-          //       _tag: 'text',
-          //       text: renderObjectLink(obj, true) + '\n',
-          //     }) satisfies ContentBlock.Text,
-          // ),
-        ]),
+        // Inline cards.
+        // ...[obj1, obj2, obj3, obj4].map(
+        //   (obj) =>
+        //     ({
+        //       _tag: 'text',
+        //       text: renderObjectLink(obj, true) + '\n',
+        //     }) satisfies ContentBlock.Text,
+        // ),
       ]),
-    );
+    ]);
   }),
 
   // Streaming text block: appends a pending text block, then mutates `text` in chunks
-  // so the syncer renders progressive deltas through the queue (not via the controller).
+  // so the syncer renders progressive deltas through the feed (not via the controller).
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
+    const { feed } = yield* Feed.ContextFeedService;
+    const feedService = yield* Feed.FeedService;
     const message = createMessage('assistant', [{ _tag: 'text', text: '', pending: true }]);
-    yield* Effect.promise(() => queue.append([message]));
+    yield* Feed.append(feed, [message]);
 
     const fullText = [
-      'Streaming a response **word by word** through the queue:',
+      'Streaming a response **word by word** through the feed:',
       random.lorem.paragraph(),
       random.lorem.paragraph(),
     ].join('\n\n');
 
     yield* Effect.promise(async () => {
       for await (const chunk of textStream(fullText, { wordsPerChunk: 2, chunkDelay: 60 })) {
-        Obj.change(message, (message) => {
+        Obj.update(message, (message) => {
           const block = message.blocks[0] as Mutable<ContentBlock.Text>;
           block.text += chunk;
         });
-        // Queue queries only react to queue-level updates, not in-place object mutations.
-        await queue.append([]);
+        // Feed queries only react to feed-level updates, not in-place object mutations.
+        await feedService.append(feed, []);
       }
-      Obj.change(message, (message) => {
+      Obj.update(message, (message) => {
         const block = message.blocks[0] as Mutable<ContentBlock.Text>;
         block.pending = false;
       });
-      await queue.append([]);
+      await feedService.append(feed, []);
     });
   }),
 
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text:
-              trim`
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text:
+            trim`
               ## Markdown
               Here is a [link](https://dxos.org)
 
@@ -129,171 +127,158 @@ export const createMessageGenerator = (): MessageGenerator[] => [
               const x = 1;
               \`\`\`
             ` + '\n',
-          },
-          {
-            _tag: 'text',
-            disposition: 'cot',
-            text:
-              [
-                random.lorem.paragraph(),
-                '',
-                ...Array.from({
-                  length: random.number.int({ min: 3, max: 5 }),
-                }).map((_, idx) => `${idx + 1}. ${random.lorem.paragraph()}`),
-              ].join('\n') + '\n',
-          },
-        ]),
+        },
+        {
+          _tag: 'text',
+          disposition: 'cot',
+          text:
+            [
+              random.lorem.paragraph(),
+              '',
+              ...Array.from({
+                length: random.number.int({ min: 3, max: 5 }),
+              }).map((_, idx) => `${idx + 1}. ${random.lorem.paragraph()}`),
+            ].join('\n') + '\n',
+        },
       ]),
-    );
+    ]);
   }),
 
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: 'How can I help?',
-          },
-          {
-            _tag: 'suggestion',
-            text: 'List tools',
-          },
-          {
-            _tag: 'suggestion',
-            text: 'Show info',
-          },
-          {
-            _tag: 'suggestion',
-            text: random.lorem.paragraph(),
-          },
-        ]),
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: 'Select an option:',
-          },
-          {
-            _tag: 'select',
-            options: ['Option 1', 'Option 2', 'Option 3'],
-          },
-        ]),
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text: 'How can I help?',
+        },
+        {
+          _tag: 'suggestion',
+          text: 'List tools',
+        },
+        {
+          _tag: 'suggestion',
+          text: 'Show info',
+        },
+        {
+          _tag: 'suggestion',
+          text: random.lorem.paragraph(),
+        },
       ]),
-    );
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text: 'Select an option:',
+        },
+        {
+          _tag: 'select',
+          options: ['Option 1', 'Option 2', 'Option 3'],
+        },
+      ]),
+    ]);
   }),
 
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'toolkit',
-          },
-        ]),
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'toolkit',
+        },
       ]),
-    );
+    ]);
   }),
 
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('user', [
-          {
-            _tag: 'text',
-            text: random.lorem.sentence(5),
-          },
-        ]),
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('user', [
+        {
+          _tag: 'text',
+          text: random.lorem.sentence(5),
+        },
       ]),
-    );
+    ]);
   }),
 
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: random.lorem.paragraph() + '\n',
-          },
-        ]),
-        createMessage('assistant', [
-          {
-            _tag: 'toolCall',
-            toolCallId: '1234',
-            name: 'search',
-            input: JSON.stringify({}),
-            providerExecuted: false,
-          },
-        ]),
-        createMessage('user', [
-          {
-            _tag: 'toolResult',
-            toolCallId: '1234',
-            name: 'search',
-            result: 'This is a tool result.',
-            providerExecuted: false,
-          },
-        ]),
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text: random.lorem.paragraph() + '\n',
+        },
       ]),
-    );
+      createMessage('assistant', [
+        {
+          _tag: 'toolCall',
+          toolCallId: '1234',
+          name: 'search',
+          input: JSON.stringify({}),
+          providerExecuted: false,
+        },
+      ]),
+      createMessage('user', [
+        {
+          _tag: 'toolResult',
+          toolCallId: '1234',
+          name: 'search',
+          result: 'This is a tool result.',
+          providerExecuted: false,
+        },
+      ]),
+    ]);
   }),
 
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: random.lorem.paragraph() + '\n',
-          },
-        ]),
-        createMessage('assistant', [
-          {
-            _tag: 'toolCall',
-            toolCallId: '4567',
-            name: 'create',
-            input: JSON.stringify({}),
-            providerExecuted: false,
-          },
-        ]),
-        createMessage('user', [
-          {
-            _tag: 'toolResult',
-            toolCallId: '4567',
-            name: 'create',
-            result: 'This is a tool result.',
-            providerExecuted: false,
-          },
-        ]),
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text:
-              Array.from({ length: random.number.int({ min: 2, max: 3 }) })
-                .map(() => random.lorem.paragraph())
-                .join('\n\n') + '\n',
-          },
-        ]),
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text: random.lorem.paragraph() + '\n',
+        },
       ]),
-    );
+      createMessage('assistant', [
+        {
+          _tag: 'toolCall',
+          toolCallId: '4567',
+          name: 'create',
+          input: JSON.stringify({}),
+          providerExecuted: false,
+        },
+      ]),
+      createMessage('user', [
+        {
+          _tag: 'toolResult',
+          toolCallId: '4567',
+          name: 'create',
+          result: 'This is a tool result.',
+          providerExecuted: false,
+        },
+      ]),
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text:
+            Array.from({ length: random.number.int({ min: 2, max: 3 }) })
+              .map(() => random.lorem.paragraph())
+              .join('\n\n') + '\n',
+        },
+      ]),
+    ]);
   }),
 
   Effect.gen(function* () {
-    const { queue } = yield* ContextQueueService;
-    yield* Effect.promise(() =>
-      queue.append([
-        createMessage('assistant', [
-          {
-            _tag: 'text',
-            text: random.lorem.paragraph(),
-          },
-        ]),
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text: random.lorem.paragraph(),
+        },
       ]),
-    );
+    ]);
   }),
 ];

package/src/testing/test-sequence.ts

@@ -3,9 +3,9 @@
 //
 
 import { ToolId } from '@dxos/ai';
-import { type SequenceDefinition, SequenceParser } from '@dxos/conductor';
+import { Sequence } from '@dxos/conductor';
 
-export const RESEARCH_SEQUENCE_DEFINITION: SequenceDefinition = {
+export const RESEARCH_SEQUENCE_DEFINITION: Sequence.Definition = {
   steps: [
     {
       instructions: 'Research information and entities related to the selected objects.',
@@ -23,4 +23,4 @@ export const RESEARCH_SEQUENCE_DEFINITION: SequenceDefinition = {
   ],
 };
 
-export const RESEARCH_SEQUENCE = SequenceParser.create().parse(RESEARCH_SEQUENCE_DEFINITION);
+export const RESEARCH_SEQUENCE = Sequence.Parser.create().parse(RESEARCH_SEQUENCE_DEFINITION);

package/src/testing/test-services.ts

@@ -6,7 +6,7 @@ import { Obj, type Type } from '@dxos/echo';
 
 import { type ApiAuthorization, type BaseServiceRegistry, ServiceType, categoryIcons } from '#types';
 
-const ServiceTypeSchema = ServiceType as unknown as Type.AnyObj;
+const ServiceTypeSchema = ServiceType as unknown as Type.Obj<ServiceType>;
 
 export class MockServiceRegistry implements BaseServiceRegistry {
   async queryServices(): Promise<ServiceType[]> {

package/src/testing/test-trace.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+
+import { Process } from '@dxos/compute';
+
+export const makeProcess = (
+  overrides: Partial<Process.Info> & Pick<Process.Info, 'pid' | 'state'> & { name: string },
+): Process.Info => ({
+  parentPid: null,
+  key: `test.process.${overrides.name}`,
+  params: { name: overrides.name, target: null },
+  error: null,
+  startedAt: Date.now() - 10_000,
+  completedAt: Option.none(),
+  metrics: { wallTime: 0, inputCount: 0, outputCount: 0 },
+  ...overrides,
+});