@dxos/react-ui-assistant 0.11.1

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

@@ -0,0 +1,75 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { describe, test } from 'vitest';
+
+import { Database, Entity, Feed, Obj } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+import { type Message } from '@dxos/types';
+
+import { createMessageGenerator } from './test-generator';
+
+/**
+ * In-memory Database.Service that records appendToFeed calls and emits a change event
+ * whenever `appendToFeed` is called. Used to verify the streaming-message generator
+ * emits per-chunk updates.
+ */
+const makeRecordingDatabaseLayer = () => {
+  const items: Message.Message[] = [];
+  const subscribers = new Set<() => void>();
+
+  const dbService: Database.Database = {
+    get spaceId() {
+      return 'recording' as any;
+    },
+    add: (obj: any) => obj as any,
+    addType: async () => undefined as any,
+    remove: () => {},
+    appendToFeed: async (_feed: Feed.Feed, newItems: Entity.Unknown[]) => {
+      items.push(...(newItems as Message.Message[]));
+      for (const fn of subscribers) {
+        fn();
+      }
+    },
+    removeFeedItemsByIds: async () => {},
+    queryFeed: () => ({ subscribe: () => () => {}, results: [], run: async () => [] }) as any,
+    query: () => ({ subscribe: () => () => {}, results: [], run: async () => [] }) as any,
+    syncFeed: async () => {},
+    getFeedSyncState: async () => ({ blocksToPull: 0, blocksToPush: 0, totalBlocks: 0 }),
+    flush: async () => {},
+    makeRef: () => undefined as any,
+    deleteFromFeed: async () => {},
+  } as unknown as Database.Database;
+
+  return {
+    items,
+    onAppend: (cb: () => void) => subscribers.add(cb),
+    layer: Layer.succeed(Database.Service, { db: dbService }),
+  };
+};
+
+describe('createMessageGenerator', () => {
+  test('streaming message publishes updates for chunk mutations', async ({ expect }) => {
+    const recording = makeRecordingDatabaseLayer();
+    let updates = 0;
+    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
+    // a real database; the recording layer stub is sufficient for this streaming test).
+    await EffectEx.runAndForwardErrors(
+      createMessageGenerator()[2]!.pipe(
+        Effect.provide(Layer.mergeAll(Feed.ContextFeedService.layer(feed), recording.layer)),
+      ),
+    );
+
+    expect(recording.items).toHaveLength(1);
+    expect(updates).toBeGreaterThan(1);
+    expect(recording.items[0].blocks[0]).toMatchObject({ pending: false });
+  });
+});

package/src/testing/test-generator.ts

@@ -0,0 +1,280 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database, Feed, Obj } from '@dxos/echo';
+import { type Mutable } from '@dxos/echo/Obj';
+import { random } from '@dxos/random';
+import { renderObjectLink, textStream } from '@dxos/react-ui-markdown';
+import { type Actor, type ContentBlock, Message, Organization } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+export const createMessage = (role: Actor.Role, blocks: ContentBlock.Any[]): Message.Message => {
+  return Obj.make(Message.Message, {
+    created: new Date().toISOString(),
+    sender: { role },
+    blocks,
+  });
+};
+
+export type MessageGenerator = Effect.Effect<void, never, Database.Service | Feed.ContextFeedService>;
+
+export const createMessageGenerator = (): MessageGenerator[] => [
+  Effect.gen(function* () {
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('user', [
+        {
+          _tag: 'text',
+          text: random.lorem.sentence(5),
+        },
+      ]),
+    ]);
+  }),
+
+  Effect.gen(function* () {
+    const { feed } = yield* Feed.ContextFeedService;
+    const { db } = yield* Database.Service;
+    const obj1 = db.add(
+      Obj.make(Organization.Organization, {
+        name: 'DXOS',
+        website: 'https://dxos.org',
+        description: 'DXOS is a decentralized network for collaborative applications.',
+      }),
+    );
+    // 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* 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,
+        // ),
+      ]),
+    ]);
+  }),
+
+  // Streaming text block: appends a pending text block, then mutates `text` in chunks
+  // so the syncer renders progressive deltas through the feed (not via the controller).
+  Effect.gen(function* () {
+    const { feed } = yield* Feed.ContextFeedService;
+    const { db } = yield* Database.Service;
+    const message = createMessage('assistant', [{ _tag: 'text', text: '', pending: true }]);
+    yield* Feed.append(feed, [message]);
+
+    const fullText = [
+      '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.update(message, (message) => {
+          const block = message.blocks[0] as Mutable<ContentBlock.Text>;
+          block.text += chunk;
+        });
+        // Feed queries only react to feed-level updates, not in-place object mutations.
+        await db.appendToFeed(feed, []);
+      }
+      Obj.update(message, (message) => {
+        const block = message.blocks[0] as Mutable<ContentBlock.Text>;
+        block.pending = false;
+      });
+      await db.appendToFeed(feed, []);
+    });
+  }),
+
+  Effect.gen(function* () {
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text:
+            trim`
+              ## Markdown
+              Here is a [link](https://dxos.org)
+
+              And some **bold** text.
+
+              And some JSON
+              \`\`\`json
+              {
+                "key": "value"
+              }
+              \`\`\`
+
+              And some code
+              \`\`\`js
+              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',
+        },
+      ]),
+    ]);
+  }),
+
+  Effect.gen(function* () {
+    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 { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'toolkit',
+        },
+      ]),
+    ]);
+  }),
+
+  Effect.gen(function* () {
+    const { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('user', [
+        {
+          _tag: 'text',
+          text: random.lorem.sentence(5),
+        },
+      ]),
+    ]);
+  }),
+
+  Effect.gen(function* () {
+    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 { 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 { feed } = yield* Feed.ContextFeedService;
+    yield* Feed.append(feed, [
+      createMessage('assistant', [
+        {
+          _tag: 'text',
+          text: random.lorem.paragraph(),
+        },
+      ]),
+    ]);
+  }),
+];

package/src/translations.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Resource } from '@dxos/react-ui';
+
+export const translationKey = '@dxos/react-ui-assistant';
+
+export const translations = [
+  {
+    'en-US': {
+      [translationKey]: {
+        'copy.label': 'Copy',
+        'rewind.label': 'Rewind to this prompt',
+        'summary.label': 'Summary',
+        'stats.label': 'Stats',
+        'tool-call.label': 'Calling',
+        'tool-result.label': 'Result',
+        'tool-error.label': 'Tool error',
+        'nav-first.label': 'First message',
+        'nav-previous.label': 'Previous message',
+        'nav-next.label': 'Next message',
+        'nav-last.label': 'Last message',
+      },
+    },
+  },
+] as const satisfies Resource[];

package/src/types.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+/**
+ * Which projection of the thread the reader sees. A view is a filter over blocks, applied by the
+ * renderer — the model always carries everything.
+ *
+ * - `summary`: only conversational text (prompts and replies).
+ * - `normal`: everything except reasoning.
+ * - `thinking`: everything, reasoning included.
+ * - `debug`: every block, raw fallbacks visible.
+ */
+export const ChatView = Schema.Union([
+  Schema.Literal('normal').annotate({ title: 'Normal' }),
+  Schema.Literal('summary').annotate({ title: 'Summary' }),
+  Schema.Literal('thinking').annotate({ title: 'Thinking' }),
+  Schema.Literal('debug').annotate({ title: 'Debug' }),
+]);
+export type ChatView = Schema.Schema.Type<typeof ChatView>;
+
+/**
+ * What the thread reports outward. Deliberately the same shapes the assistant plugin's event bus
+ * speaks, so a host can pipe these straight through.
+ */
+export type ChatThreadEvent =
+  /** A suggestion or select option was chosen — the text is ready to submit. */
+  | { type: 'submit'; text: string }
+  /** Soft-fork the thread from the given message (the prompt toolbar's rewind). */
+  | { type: 'rewind'; id: string };