@dxos/assistant 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/assistant",
-  "version": "0.8.4-main.937b3ca",
+  "version": "0.8.4-main.9be5663bfe",
   "description": "Natural language interface to DXOS",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -16,20 +16,17 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     },
     "./extraction": {
       "source": "./src/extraction/index.ts",
       "types": "./dist/types/src/extraction/index.d.ts",
-      "browser": "./dist/lib/browser/extraction/index.mjs",
-      "node": "./dist/lib/node-esm/extraction/index.mjs"
+      "default": "./dist/lib/neutral/extraction/index.mjs"
     },
     "./testing": {
       "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
-      "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/index.mjs"
+      "default": "./dist/lib/neutral/testing/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -49,39 +46,42 @@
   ],
   "dependencies": {
     "@automerge/automerge": "3.2.3",
-    "@effect-atom/atom-react": "^0.4.6",
-    "@effect/ai": "0.32.1",
-    "@effect/experimental": "0.57.11",
-    "@effect/platform": "0.93.6",
+    "@effect-atom/atom": "^0.5.1",
+    "@effect-atom/atom-react": "^0.5.0",
+    "@effect/ai": "0.33.2",
+    "@effect/experimental": "0.58.0",
+    "@effect/platform": "0.94.4",
     "@xenova/transformers": "^2.17.2",
     "lodash.defaultsdeep": "^4.6.1",
-    "@dxos/ai": "0.8.4-main.937b3ca",
-    "@dxos/context": "0.8.4-main.937b3ca",
-    "@dxos/blueprints": "0.8.4-main.937b3ca",
-    "@dxos/async": "0.8.4-main.937b3ca",
-    "@dxos/debug": "0.8.4-main.937b3ca",
-    "@dxos/echo": "0.8.4-main.937b3ca",
-    "@dxos/echo-db": "0.8.4-main.937b3ca",
-    "@dxos/echo-protocol": "0.8.4-main.937b3ca",
-    "@dxos/effect": "0.8.4-main.937b3ca",
-    "@dxos/functions": "0.8.4-main.937b3ca",
-    "@dxos/graph": "0.8.4-main.937b3ca",
-    "@dxos/functions-runtime": "0.8.4-main.937b3ca",
-    "@dxos/keys": "0.8.4-main.937b3ca",
-    "@dxos/invariant": "0.8.4-main.937b3ca",
-    "@dxos/node-std": "0.8.4-main.937b3ca",
-    "@dxos/log": "0.8.4-main.937b3ca",
-    "@dxos/schema": "0.8.4-main.937b3ca",
-    "@dxos/util": "0.8.4-main.937b3ca",
-    "@dxos/errors": "0.8.4-main.937b3ca",
-    "@dxos/types": "0.8.4-main.937b3ca"
+    "@dxos/ai": "0.8.4-main.9be5663bfe",
+    "@dxos/async": "0.8.4-main.9be5663bfe",
+    "@dxos/debug": "0.8.4-main.9be5663bfe",
+    "@dxos/echo-db": "0.8.4-main.9be5663bfe",
+    "@dxos/context": "0.8.4-main.9be5663bfe",
+    "@dxos/echo-protocol": "0.8.4-main.9be5663bfe",
+    "@dxos/echo": "0.8.4-main.9be5663bfe",
+    "@dxos/effect": "0.8.4-main.9be5663bfe",
+    "@dxos/functions": "0.8.4-main.9be5663bfe",
+    "@dxos/errors": "0.8.4-main.9be5663bfe",
+    "@dxos/functions-runtime": "0.8.4-main.9be5663bfe",
+    "@dxos/blueprints": "0.8.4-main.9be5663bfe",
+    "@dxos/invariant": "0.8.4-main.9be5663bfe",
+    "@dxos/graph": "0.8.4-main.9be5663bfe",
+    "@dxos/keys": "0.8.4-main.9be5663bfe",
+    "@dxos/log": "0.8.4-main.9be5663bfe",
+    "@dxos/node-std": "0.8.4-main.9be5663bfe",
+    "@dxos/mcp-client": "0.8.4-main.9be5663bfe",
+    "@dxos/operation": "0.8.4-main.9be5663bfe",
+    "@dxos/schema": "0.8.4-main.9be5663bfe",
+    "@dxos/types": "0.8.4-main.9be5663bfe",
+    "@dxos/util": "0.8.4-main.9be5663bfe"
   },
   "devDependencies": {
     "@types/lodash.defaultsdeep": "^4.6.6",
-    "effect": "3.19.11"
+    "effect": "3.20.0"
   },
   "peerDependencies": {
-    "effect": "3.19.11"
+    "effect": "3.20.0"
   },
   "publishConfig": {
     "access": "public"

package/src/conversation/context.test.ts

@@ -2,35 +2,41 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Runtime from 'effect/Runtime';
 import * as Schema from 'effect/Schema';
 import { describe, it } from 'vitest';
 
-import { Obj, Ref, Type } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-db';
+import { Feed, Obj, Ref, Type } from '@dxos/echo';
 
 import { AiContextBinder } from './context';
 
-// TODO(burdon): Create mock queue?
-const createMockQueue = (): Queue =>
-  ({
+const createMockFeedRuntime = (): Runtime.Runtime<Feed.FeedService> => {
+  const mockFeedService: Context.Tag.Service<Feed.FeedService> = {
+    append: async () => {},
+    remove: async () => {},
     query: () =>
       ({
-        subscribe: () => ({ unsubscribe: () => {} }),
+        subscribe: () => () => {},
         results: [],
+        run: async () => [],
       }) as any,
-    append: async () => {
-      return [] as any;
-    },
-  }) as any;
+  };
+  const layer = Layer.succeed(Feed.FeedService, mockFeedService);
+  return Effect.runSync(Effect.runtime<Feed.FeedService>().pipe(Effect.provide(layer)));
+};
 
 describe('AiContextBinder', () => {
   it('should handle bind with Ref', async () => {
-    const queue = createMockQueue();
-    const binder = new AiContextBinder({ queue });
+    const feed = Feed.make();
+    const runtime = createMockFeedRuntime();
+    const binder = new AiContextBinder({ feed, runtime });
 
     const TestSchema = Schema.Struct({}).pipe(
       Type.object({
-        typename: 'dxos.org/type/Example',
+        typename: 'org.dxos.type.example',
         version: '0.1.0',
       }),
     );

package/src/conversation/context.ts

@@ -5,15 +5,17 @@
 import { Atom, Registry } from '@effect-atom/atom-react';
 import * as EArray from 'effect/Array';
 import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
+import * as Runtime from 'effect/Runtime';
 import * as Schema from 'effect/Schema';
 
 import { Blueprint } from '@dxos/blueprints';
 import { Resource } from '@dxos/context';
-import { DXN, Obj, Query, type Ref, Type } from '@dxos/echo';
-import { type Queue } from '@dxos/echo-db';
+import { DXN, Feed, Obj, type QueryResult, Query, Ref, Type } from '@dxos/echo';
+import { assertArgument } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { ComplexSet, isTruthy } from '@dxos/util';
+import { ComplexSet, isNonNullable } from '@dxos/util';
 
 /**
  * Thread message that binds or unbinds contextual objects to a conversation.
@@ -21,17 +23,17 @@ import { ComplexSet, isTruthy } from '@dxos/util';
 // TODO(burdon): Move to @dxos/schema ContentBlock?
 export const ContextBinding = Schema.Struct({
   blueprints: Schema.Struct({
-    added: Schema.Array(Type.Ref(Blueprint.Blueprint)),
-    removed: Schema.Array(Type.Ref(Blueprint.Blueprint)),
+    added: Schema.Array(Ref.Ref(Blueprint.Blueprint)),
+    removed: Schema.Array(Ref.Ref(Blueprint.Blueprint)),
   }),
 
   objects: Schema.Struct({
-    added: Schema.Array(Type.Ref(Type.Obj)),
-    removed: Schema.Array(Type.Ref(Type.Obj)),
+    added: Schema.Array(Ref.Ref(Obj.Unknown)),
+    removed: Schema.Array(Ref.Ref(Obj.Unknown)),
   }),
 }).pipe(
   Type.object({
-    typename: 'dxos.org/type/ContextBinding',
+    typename: 'org.dxos.type.contextBinding',
     version: '0.1.0',
   }),
 );
@@ -58,7 +60,8 @@ export class Bindings {
 }
 
 export type AiContextBinderOptions = {
-  queue: Queue;
+  feed: Feed.Feed;
+  runtime: Runtime.Runtime<Feed.FeedService>;
   registry?: Registry.Registry;
 };
 
@@ -70,11 +73,16 @@ export class AiContextBinder extends Resource {
   private readonly _blueprints = Atom.make<Blueprint.Blueprint[]>([]).pipe(Atom.keepAlive);
   private readonly _objects = Atom.make<Obj.Unknown[]>([]).pipe(Atom.keepAlive);
   private readonly _registry: Registry.Registry;
-  private readonly _queue: Queue;
+  private readonly _feed: Feed.Feed;
+  private readonly _runtime: Runtime.Runtime<Feed.FeedService>;
+  #bindingsQuery: QueryResult.QueryResult<ContextBinding> | undefined;
 
   constructor(options: AiContextBinderOptions) {
     super();
-    this._queue = options.queue;
+    assertArgument(options.feed, 'options.feed', 'Feed is required');
+    assertArgument(options.runtime, 'options.runtime', 'Feed runtime is required');
+    this._feed = options.feed;
+    this._runtime = options.runtime;
     this._registry = options.registry ?? Registry.make();
   }
 
@@ -121,20 +129,35 @@ export class AiContextBinder extends Resource {
   }
 
   protected override async _open(): Promise<void> {
-    const query = this._queue.query(Query.type(ContextBinding));
+    this.#bindingsQuery = await Runtime.runPromise(this._runtime)(Feed.query(this._feed, Query.type(ContextBinding)));
 
     // Process initial state before returning.
-    const initialResults = await query.run();
+    const initialResults = await this.#bindingsQuery.run();
     await this._updateBindings(initialResults);
 
     // Subscribe to future changes.
     this._ctx.onDispose(
-      query.subscribe(async () => {
-        await this._updateBindings(query.results);
+      this.#bindingsQuery.subscribe(async () => {
+        await this._updateBindings(this.#bindingsQuery!.results);
       }),
     );
   }
 
+  /**
+   * Re-reads bindings from the feed to pick up changes made by other processes.
+   */
+  async sync(): Promise<void> {
+    if (this.#bindingsQuery) {
+      const results = await this.#bindingsQuery.run();
+      log('sync', { bindingItems: results.length });
+      await this._updateBindings(results);
+      log('sync complete', {
+        blueprints: this._registry.get(this._blueprints).length,
+        blueprintKeys: this._registry.get(this._blueprints).map((bp) => (bp as any).key),
+      });
+    }
+  }
+
   private async _updateBindings(items: ContextBinding[]): Promise<void> {
     // Skip update if no items - preserve existing state set by bind().
     if (items.length === 0) {
@@ -143,19 +166,43 @@ export class AiContextBinder extends Resource {
 
     const bindings = this._reduce(items);
 
+    log('_updateBindings', {
+      items: items.length,
+      blueprintRefs: [...bindings.blueprints].map((ref) => ({ dxn: ref.dxn.toString(), available: ref.isAvailable })),
+    });
+
     // Resolve references (loading them first if needed).
     const currentBlueprints = this._registry.get(this._blueprints);
     const currentObjects = this._registry.get(this._objects);
-    const newBlueprints = await this._resolve(bindings.blueprints, currentBlueprints);
-    const newObjects = await this._resolve(bindings.objects, currentObjects);
+    const resolvedBlueprints = await this._resolve(bindings.blueprints, currentBlueprints);
+    const resolvedObjects = await this._resolve(bindings.objects, currentObjects);
 
-    // Atomic updates - subscribers notified automatically.
-    this._registry.set(this._blueprints, newBlueprints);
-    this._registry.set(this._objects, newObjects);
+    log('_updateBindings resolved', {
+      resolvedBlueprints: resolvedBlueprints.length,
+      resolvedBlueprintKeys: resolvedBlueprints.map((bp) => (bp as any).key),
+    });
+
+    // Filter current state to only items still in the reduced binding set,
+    // then merge in newly resolved items. This ensures unbind events are respected.
+    const reducedBlueprintDxns = new ComplexSet<DXN>(
+      DXN.hash,
+      [...bindings.blueprints].map((ref) => ref.dxn),
+    );
+    const reducedObjectDxns = new ComplexSet<DXN>(
+      DXN.hash,
+      [...bindings.objects].map((ref) => ref.dxn),
+    );
+    const filteredBlueprints = currentBlueprints.filter((obj) => reducedBlueprintDxns.has(Obj.getDXN(obj)));
+    const filteredObjects = currentObjects.filter((obj) => reducedObjectDxns.has(Obj.getDXN(obj)));
+    const mergedBlueprints = this._mergeInto(filteredBlueprints, resolvedBlueprints);
+    const mergedObjects = this._mergeInto(filteredObjects, resolvedObjects);
+
+    this._registry.set(this._blueprints, mergedBlueprints);
+    this._registry.set(this._objects, mergedObjects);
 
     log('updated bindings', {
-      blueprints: newBlueprints.length,
-      objects: newObjects.length,
+      blueprints: mergedBlueprints.length,
+      objects: mergedObjects.length,
     });
   }
 
@@ -180,18 +227,20 @@ export class AiContextBinder extends Resource {
     this._registry.set(this._objects, nextObjects);
 
     log('bind', { blueprints: addedBlueprints.length, objects: addedObjects.length });
-    await this._queue.append([
-      Obj.make(ContextBinding, {
-        blueprints: {
-          added: addedBlueprints,
-          removed: [],
-        },
-        objects: {
-          added: addedObjects,
-          removed: [],
-        },
-      }),
-    ]);
+    await Runtime.runPromise(this._runtime)(
+      Feed.append(this._feed, [
+        Obj.make(ContextBinding, {
+          blueprints: {
+            added: addedBlueprints,
+            removed: [],
+          },
+          objects: {
+            added: addedObjects,
+            removed: [],
+          },
+        }),
+      ]),
+    );
   }
 
   async unbind({ blueprints, objects }: BindingProps): Promise<void> {
@@ -199,19 +248,39 @@ export class AiContextBinder extends Resource {
       return;
     }
 
+    // Immediately update atom state so removals are reflected before the queue round-trips.
+    const removedBlueprintDxns = (blueprints ?? []).map((ref) => ref.dxn);
+    const removedObjectDxns = (objects ?? []).map((ref) => ref.dxn);
+    if (removedBlueprintDxns.length > 0) {
+      const current = this._registry.get(this._blueprints);
+      this._registry.set(
+        this._blueprints,
+        current.filter((obj) => !removedBlueprintDxns.some((dxn) => DXN.equalsEchoId(Obj.getDXN(obj), dxn))),
+      );
+    }
+    if (removedObjectDxns.length > 0) {
+      const current = this._registry.get(this._objects);
+      this._registry.set(
+        this._objects,
+        current.filter((obj) => !removedObjectDxns.some((dxn) => DXN.equalsEchoId(Obj.getDXN(obj), dxn))),
+      );
+    }
+
     log('unbind', { blueprints: blueprints?.length, objects: objects?.length });
-    await this._queue.append([
-      Obj.make(ContextBinding, {
-        blueprints: {
-          added: [],
-          removed: blueprints ?? [],
-        },
-        objects: {
-          added: [],
-          removed: objects ?? [],
-        },
-      }),
-    ]);
+    await Runtime.runPromise(this._runtime)(
+      Feed.append(this._feed, [
+        Obj.make(ContextBinding, {
+          blueprints: {
+            added: [],
+            removed: blueprints ?? [],
+          },
+          objects: {
+            added: [],
+            removed: objects ?? [],
+          },
+        }),
+      ]),
+    );
   }
 
   /**
@@ -271,14 +340,30 @@ export class AiContextBinder extends Resource {
     );
   }
 
+  /**
+   * Merge resolved items into the current set, adding only items not already present (by DXN).
+   */
+  private _mergeInto<T extends Obj.Unknown>(current: T[], resolved: T[]): T[] {
+    const seen = new Set(current.map((obj) => Obj.getDXN(obj).toString()));
+    const merged = [...current];
+    for (const obj of resolved) {
+      const dxn = Obj.getDXN(obj).toString();
+      if (!seen.has(dxn)) {
+        seen.add(dxn);
+        merged.push(obj);
+      }
+    }
+    return merged;
+  }
+
   /**
    * Resolve references to objects, loading them first if needed and falling back to existing objects.
    */
-  private async _resolve<T>(refs: Iterable<Ref.Ref<T>>, current: T[]): Promise<T[]> {
+  private async _resolve<T extends Obj.Unknown>(refs: Iterable<Ref.Ref<T>>, current: T[]): Promise<T[]> {
     const refArray = [...refs];
 
     // Load all refs that need loading.
-    await Promise.all(refArray.map((ref) => ref.load()));
+    await Promise.all(refArray.map((ref) => ref.tryLoad()));
 
     return refArray
       .map((ref) => {
@@ -291,7 +376,7 @@ export class AiContextBinder extends Resource {
         // Fallback to existing object.
         return target ?? current.find((obj) => Obj.getDXN(obj as any).toString() === ref.dxn.toString());
       })
-      .filter(isTruthy);
+      .filter(isNonNullable);
   }
 }
 
@@ -300,4 +385,19 @@ export class AiContextService extends Context.Tag('@dxos/assistant/AiContextServ
   {
     binder: AiContextBinder;
   }
->() {}
+>() {
+  static bindContext = ({ blueprints, objects }: BindingProps): Effect.Effect<void, never, AiContextService> =>
+    Effect.gen(function* () {
+      const { binder } = yield* AiContextService;
+      yield* Effect.promise(() => binder.bind({ blueprints, objects }));
+    });
+
+  static findObjects = <T extends Type.AnyEntity>(
+    type: T,
+  ): Effect.Effect<Schema.Schema.Type<T>[], never, AiContextService> => {
+    return Effect.gen(function* () {
+      const { binder } = yield* AiContextService;
+      return binder.getObjects().filter(Obj.instanceOf(type));
+    });
+  };
+}

package/src/conversation/conversation.test.ts

@@ -4,32 +4,26 @@
 
 import { it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
-import { afterEach, beforeEach, describe, expect } from 'vitest';
+import { describe, expect } from 'vitest';
 
 import { Blueprint } from '@dxos/blueprints';
-import { Obj, Ref } from '@dxos/echo';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { Database, Feed, Obj, Ref } from '@dxos/echo';
+import { TestDatabaseLayer } from '@dxos/functions-runtime/testing';
 
 import { ContextBinding } from './context';
 import { AiConversation } from './conversation';
 
 describe('AiConversation', () => {
-  let builder: EchoTestBuilder;
-
-  beforeEach(async () => {
-    builder = await new EchoTestBuilder().open();
-  });
-
-  afterEach(async () => {
-    await builder.close();
+  const TestLayer = TestDatabaseLayer({
+    types: [Blueprint.Blueprint, ContextBinding],
   });
 
   it.effect('loads blueprints on open', () =>
     Effect.gen(function* () {
-      const peer = yield* Effect.promise(() => builder.createPeer({ types: [Blueprint.Blueprint, ContextBinding] }));
-      const db = yield* Effect.promise(() => peer.createDatabase());
-      const queues = peer.client.constructQueueFactory(db.spaceId);
-      const queue = queues.create<ContextBinding>();
+      const { db } = yield* Database.Service;
+
+      // Create feed.
+      const feed = db.add(Feed.make());
 
       // Create blueprint.
       const blueprint = db.add(
@@ -39,27 +33,26 @@ describe('AiConversation', () => {
         }),
       );
 
-      // Add blueprint to queue via binding.
-      yield* Effect.promise(() =>
-        queue.append([
-          Obj.make(ContextBinding, {
-            blueprints: {
-              added: [Ref.make(blueprint)],
-              removed: [],
-            },
-            objects: {
-              added: [],
-              removed: [],
-            },
-          }),
-        ]),
-      );
+      // Add blueprint to feed via binding.
+      yield* Feed.append(feed, [
+        Obj.make(ContextBinding, {
+          blueprints: {
+            added: [Ref.make(blueprint)],
+            removed: [],
+          },
+          objects: {
+            added: [],
+            removed: [],
+          },
+        }),
+      ]);
 
-      const conversation = new AiConversation({ queue });
+      const runtime = yield* Effect.runtime<Feed.FeedService>();
+      const conversation = new AiConversation({ feed, runtime });
       yield* Effect.promise(() => conversation.open());
 
       expect(conversation.context.getBlueprints()).toHaveLength(1);
       expect(conversation.context.getObjects()).toHaveLength(0);
-    }),
+    }).pipe(Effect.provide(TestLayer)),
   );
 });