@dxos/plugin-assistant 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/src/queue-logger.ts

@@ -2,17 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { getSpace, Ref, type Queue, type Space } from '@dxos/client/echo';
+import { type Queue, Ref, type Space, getSpace } from '@dxos/client/echo';
 import { type Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
-import { DXN, Key, Obj } from '@dxos/echo';
-import {
-  InvocationOutcome,
-  InvocationTraceEndEvent,
-  InvocationTraceEventType,
-  InvocationTraceStartEvent,
-  TraceEvent,
-  type InvocationTraceEvent,
-} from '@dxos/functions';
+import { DXN, Feed, Obj } from '@dxos/echo';
+import { InvocationTraceEndEvent, InvocationTraceEventType, InvocationTraceStartEvent } from '@dxos/functions-runtime';
+import { TraceEvent } from '@dxos/functions-runtime';
+import { InvocationOutcome } from '@dxos/functions-runtime';
+import { type InvocationTraceEvent } from '@dxos/functions-runtime';
 import { invariant } from '@dxos/invariant';
 import { QueueSubspaceTags } from '@dxos/keys';
 
@@ -24,12 +20,26 @@ export class QueueLogger implements SequenceLogger {
     const space = getSpace(sequence);
     invariant(space, 'Space not found');
     this._space = space;
-    let dxn = this._space.properties.invocationTraceQueue?.dxn;
-    if (!dxn) {
-      dxn = DXN.fromQueue(QueueSubspaceTags.TRACE, this._space.id, Key.ObjectId.random());
-      this._space.properties.invocationTraceQueue = Ref.fromDXN(dxn);
+
+    const existingFeedRef = this._space.properties.invocationTraceFeed;
+    let queueDxn: DXN | undefined;
+
+    if (existingFeedRef) {
+      // A feed reference exists; resolve its queue DXN. If the target isn't loaded yet,
+      // fail loudly rather than silently creating a new feed and orphaning existing traces.
+      invariant(existingFeedRef.target, 'invocationTraceFeed reference is not yet loaded');
+      queueDxn = Feed.getQueueDxn(existingFeedRef.target) ?? undefined;
+      invariant(queueDxn, 'invocationTraceFeed has no queue DXN');
+    } else {
+      const feed = space.db.add(Feed.make({ namespace: 'trace' }));
+      queueDxn = Feed.getQueueDxn(feed) ?? undefined;
+      invariant(queueDxn, 'New invocationTraceFeed has no queue DXN');
+      Obj.change(this._space.properties, (obj) => {
+        obj.invocationTraceFeed = Ref.make(feed);
+      });
     }
-    this._invocationTraceQueue = this._space.queues.get(dxn);
+
+    this._invocationTraceQueue = this._space.queues.get(queueDxn);
   }
 
   log(event: SequenceEvent) {
@@ -39,7 +49,7 @@ export class QueueLogger implements SequenceLogger {
           Obj.make(InvocationTraceStartEvent, {
             type: InvocationTraceEventType.START,
             invocationId: event.invocationId,
-            timestampMs: Date.now(),
+            timestamp: Date.now(),
             input: {},
             invocationTraceQueue: Ref.fromDXN(this._getTraceQueueDxn(event.invocationId)),
             invocationTarget: Ref.make(this.sequence),
@@ -51,7 +61,7 @@ export class QueueLogger implements SequenceLogger {
           Obj.make(InvocationTraceEndEvent, {
             type: InvocationTraceEventType.END,
             invocationId: event.invocationId,
-            timestampMs: Date.now(),
+            timestamp: Date.now(),
             outcome: InvocationOutcome.SUCCESS,
           }),
         ]);
@@ -62,10 +72,10 @@ export class QueueLogger implements SequenceLogger {
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
-            ingestionTimestampMs: Date.now(),
+            ingestionTimestamp: Date.now(),
             logs: [
               {
-                timestampMs: Date.now(),
+                timestamp: Date.now(),
                 level: 'info',
                 message: event.type,
                 context: { step: event.step },
@@ -80,10 +90,10 @@ export class QueueLogger implements SequenceLogger {
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
-            ingestionTimestampMs: Date.now(),
+            ingestionTimestamp: Date.now(),
             logs: [
               {
-                timestampMs: Date.now(),
+                timestamp: Date.now(),
                 level: 'info',
                 message: event.type,
                 context: { message: event.message },
@@ -98,10 +108,10 @@ export class QueueLogger implements SequenceLogger {
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
-            ingestionTimestampMs: Date.now(),
+            ingestionTimestamp: Date.now(),
             logs: [
               {
-                timestampMs: Date.now(),
+                timestamp: Date.now(),
                 level: 'info',
                 message: event.type,
                 context: { block: event.block },

package/src/testing/index.ts

@@ -2,6 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './test-generator';
 export * from './test-sequence';
-export * from './test-functions';
 export * from './test-services';

package/src/testing/test-generator.ts

@@ -0,0 +1,293 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Obj } from '@dxos/echo';
+import { Database } 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 { 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 | ContextQueueService>;
+
+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),
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  // 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).
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    const message = createMessage('assistant', [{ _tag: 'text', text: '', pending: true }]);
+    yield* Effect.promise(() => queue.append([message]));
+
+    const fullText =
+      trim`
+      Streaming a response **word by word** through the queue:
+
+      ${random.lorem.paragraph()}
+
+      ${random.lorem.paragraph()}
+    ` + '\n';
+
+    yield* Effect.promise(async () => {
+      for await (const chunk of textStream(fullText, { wordsPerChunk: 2, chunkDelay: 60 })) {
+        Obj.change(message, (message) => {
+          const block = message.blocks[0] as Mutable<ContentBlock.Text>;
+          block.text += chunk;
+        });
+      }
+      Obj.change(message, (message) => {
+        const block = message.blocks[0] as Mutable<ContentBlock.Text>;
+        block.pending = false;
+      });
+    });
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        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 { 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'],
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        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),
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    const { db } = yield* Database.Service;
+    const obj1 = db.add(Obj.make(Organization.Organization, { name: 'DXOS' }));
+    // 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(' '),
+          },
+
+          // Inline cards.
+          // ...[obj1, obj2, obj3, obj4].map(
+          //   (obj) =>
+          //     ({
+          //       _tag: 'text',
+          //       text: renderObjectLink(obj, true) + '\n',
+          //     }) satisfies ContentBlock.Text,
+          // ),
+        ]),
+      ]),
+    );
+  }),
+
+  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,
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  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',
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('assistant', [
+          {
+            _tag: 'text',
+            text: random.lorem.paragraph(),
+          },
+        ]),
+      ]),
+    );
+  }),
+];

package/src/testing/test-sequence.ts

@@ -2,50 +2,23 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ToolRegistry } from '@dxos/ai';
-import { EXA_API_KEY } from '@dxos/ai/testing';
-import { createExaTool, createGraphWriterTool, createLocalSearchTool } from '@dxos/assistant';
-import { type Space } from '@dxos/client/echo';
-import { SequenceParser, type SequenceDefinition } from '@dxos/conductor';
-import { type DXN } from '@dxos/keys';
-import { DataTypes } from '@dxos/schema';
-import { isNonNullable } from '@dxos/util';
-
-// TODO(dmaretskyi): make db available through services (same as function executor).
-// TODO(burdon): Can tools implement "aspects" so that variants can be used rather than an explicit reference?
-export const createToolRegistry = (space: Space, queueDxn?: DXN): ToolRegistry => {
-  return new ToolRegistry(
-    [
-      createExaTool({ apiKey: EXA_API_KEY }),
-      createLocalSearchTool(space.db, queueDxn && space.queues.get(queueDxn)),
-      queueDxn &&
-        createGraphWriterTool({
-          db: space.db,
-          queue: space.queues.get(queueDxn),
-          schema: DataTypes,
-          onDone: async (objects) => {
-            const queue = space.queues.get(queueDxn);
-            await queue.append(objects);
-          },
-        }),
-    ].filter(isNonNullable),
-  );
-};
+import { ToolId } from '@dxos/ai';
+import { type SequenceDefinition, SequenceParser } from '@dxos/conductor';
 
 export const RESEARCH_SEQUENCE_DEFINITION: SequenceDefinition = {
   steps: [
     {
       instructions: 'Research information and entities related to the selected objects.',
-      tools: ['search/web_search'],
+      tools: [ToolId.make('search/web-search')],
     },
     {
       instructions:
         'Based on your research find matching entires that are already in the graph. Do exaustive research.',
-      tools: ['search/local_search'],
+      tools: [ToolId.make('search/local-search')],
     },
     {
       instructions: 'Add researched data to the graph. Make connections to existing objects.',
-      tools: ['search/local_search', 'graph/writer'],
+      tools: [ToolId.make('search/local-search'), ToolId.make('graph/writer')],
     },
   ],
 };

package/src/testing/test-services.ts

@@ -2,18 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Obj } from '@dxos/echo';
+import { Obj, type Type } from '@dxos/echo';
 
-import {
-  type ApiAuthorization,
-  type BaseServiceRegistry,
-  type ServiceQuery,
-  ServiceType,
-  categoryIcons,
-} from '../types';
+import { type ApiAuthorization, type BaseServiceRegistry, ServiceType, categoryIcons } from '#types';
+
+const ServiceTypeSchema = ServiceType as unknown as Type.AnyObj;
 
 export class MockServiceRegistry implements BaseServiceRegistry {
-  async queryServices(query?: ServiceQuery): Promise<ServiceType[]> {
+  async queryServices(): Promise<ServiceType[]> {
     return TEST_SERVICES;
   }
 }
@@ -54,7 +50,7 @@ const VISUAL_CROSSING_CREDENTIALS: ApiAuthorization = {
 //  - e.g., https://github.com/konfig-sdks/openapi-examples/blob/main/xkcd/openapi.yaml
 
 const TEST_SERVICES: ServiceType[] = [
-  Obj.make(ServiceType, {
+  Obj.make(ServiceTypeSchema, {
     serviceId: 'amadeus.com/service/FlightSearch',
     name: 'Amadeus Flight Search',
     description: 'Search for local and international flights.',
@@ -68,7 +64,7 @@ const TEST_SERVICES: ServiceType[] = [
     ],
   }),
 
-  Obj.make(ServiceType, {
+  Obj.make(ServiceTypeSchema, {
     serviceId: 'amadeus.com/service/HotelSearch',
     name: 'Amadeus Hotel Search',
     description: 'Search for local and international hotels.',
@@ -82,7 +78,7 @@ const TEST_SERVICES: ServiceType[] = [
     ],
   }),
 
-  Obj.make(ServiceType, {
+  Obj.make(ServiceTypeSchema, {
     serviceId: 'visualcrossing.com/service/Weather',
     name: 'Visual Crossing Weather',
     description: 'Search for global weather forecasts.',
@@ -97,7 +93,7 @@ const TEST_SERVICES: ServiceType[] = [
   }),
 
   // TODO(burdon): Needs auth.
-  Obj.make(ServiceType, {
+  Obj.make(ServiceTypeSchema, {
     serviceId: 'abstractapi.com/service/GeoLocation',
     name: 'Abstract GeoLocation',
     description: 'Get the location of any IP address.',
@@ -115,7 +111,7 @@ const TEST_SERVICES: ServiceType[] = [
   //
 
   ...Array.from({ length: 20 }, (_, i) =>
-    Obj.make(ServiceType, {
+    Obj.make(ServiceTypeSchema, {
       serviceId: `example.com/service/test-${i}`,
       name: `Test ${i}`,
       description: `Test ${i}`,