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

package/src/containers/TracePanel/span-tree.test.ts

@@ -0,0 +1,166 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { AgentRequestBegin, AgentRequestEnd } from '@dxos/assistant';
+import { Trace } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+
+import { ROOT_SPAN_ID, buildSpanTree, flattenSpanTree } from './span-tree';
+
+const makeMessage = (
+  meta: Trace.Meta,
+  events: Array<{ type: string; timestamp: number; data?: unknown }>,
+  isEphemeral = false,
+): Trace.Message =>
+  Obj.make(Trace.Message, {
+    meta,
+    isEphemeral,
+    events: events.map((event) => ({
+      type: event.type,
+      timestamp: event.timestamp,
+      data: event.data ?? {},
+    })),
+  });
+
+const opStart = (key: string, name?: string) => ({
+  type: Trace.OperationStart.key,
+  data: { key, name },
+});
+const opEnd = (key: string, name?: string, outcome: 'success' | 'failure' = 'success') => ({
+  type: Trace.OperationEnd.key,
+  data: { key, name, outcome },
+});
+const agentBegin = () => ({ type: AgentRequestBegin.key, data: {} });
+const agentEnd = () => ({ type: AgentRequestEnd.key, data: {} });
+
+describe('buildSpanTree', () => {
+  test('returns a root span for empty input', ({ expect }) => {
+    const tree = buildSpanTree([]);
+    expect(tree.id).toBe(ROOT_SPAN_ID);
+    expect(tree.children).toEqual([]);
+    expect(tree.events).toEqual([]);
+  });
+
+  test('events without pid attach to root span', ({ expect }) => {
+    const tree = buildSpanTree([makeMessage({}, [{ type: 'foo', timestamp: 1 }])]);
+    expect(tree.children).toEqual([]);
+    expect(tree.events).toHaveLength(1);
+    expect(tree.events[0].type).toBe('foo');
+  });
+
+  test('a single operation start/end pair produces one span under root', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'op-1' }, [{ ...opStart('reply', 'Reply'), timestamp: 1 }]),
+      makeMessage({ pid: 'op-1' }, [{ ...opEnd('reply', 'Reply'), timestamp: 2 }]),
+    ]);
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].meta.pid).toBe('op-1');
+    expect(tree.children[0].events).toHaveLength(2);
+    expect(tree.children[0].children).toEqual([]);
+  });
+
+  test('a nested operation attaches to its open parent', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 1 }]),
+      makeMessage({ pid: 'op-1', parentPid: 'agent-1' }, [{ ...opStart('lookup', 'Lookup'), timestamp: 2 }]),
+      makeMessage({ pid: 'op-1', parentPid: 'agent-1' }, [{ ...opEnd('lookup', 'Lookup'), timestamp: 3 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 4 }]),
+    ]);
+    expect(tree.children).toHaveLength(1);
+    const agentSpan = tree.children[0];
+    expect(agentSpan.meta.pid).toBe('agent-1');
+    expect(agentSpan.children).toHaveLength(1);
+    expect(agentSpan.children[0].meta.pid).toBe('op-1');
+    expect(agentSpan.children[0].events).toHaveLength(2);
+  });
+
+  test('sequential agent requests in one process become sibling spans', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 1 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 2 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 3 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 4 }]),
+    ]);
+    expect(tree.children).toHaveLength(2);
+    expect(tree.children.every((child) => child.meta.pid === 'agent-1')).toBe(true);
+    // Span ids are distinct even though pids are shared.
+    expect(tree.children[0].id).not.toBe(tree.children[1].id);
+  });
+
+  test('non-boundary events attach to the currently-open span', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 1 }]),
+      makeMessage({ pid: 'agent-1' }, [{ type: 'note', timestamp: 2 }]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 3 }]),
+    ]);
+    expect(tree.children[0].events).toHaveLength(3);
+    expect(tree.children[0].events.map((event) => event.type)).toEqual([
+      AgentRequestBegin.key,
+      'note',
+      AgentRequestEnd.key,
+    ]);
+  });
+
+  test('non-boundary event without an open span lands on root', ({ expect }) => {
+    const tree = buildSpanTree([makeMessage({ pid: 'orphan-pid' }, [{ type: 'note', timestamp: 1 }])]);
+    expect(tree.children).toEqual([]);
+    expect(tree.events).toHaveLength(1);
+    expect(tree.events[0].type).toBe('note');
+  });
+
+  test('end event without a matching begin attaches to root', ({ expect }) => {
+    const tree = buildSpanTree([makeMessage({ pid: 'op-1' }, [{ ...opEnd('reply', 'Reply'), timestamp: 1 }])]);
+    expect(tree.children).toEqual([]);
+    expect(tree.events).toHaveLength(1);
+  });
+
+  test('sorts sibling spans chronologically by their first event', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'op-late' }, [
+        { ...opStart('b'), timestamp: 10 },
+        { ...opEnd('b'), timestamp: 11 },
+      ]),
+      makeMessage({ pid: 'op-early' }, [
+        { ...opStart('a'), timestamp: 1 },
+        { ...opEnd('a'), timestamp: 2 },
+      ]),
+    ]);
+    expect(tree.children.map((child) => child.meta.pid)).toEqual(['op-early', 'op-late']);
+  });
+
+  test('respects eventLimit by dropping oldest events', ({ expect }) => {
+    const tree = buildSpanTree(
+      [
+        makeMessage({ pid: 'op-old' }, [
+          { ...opStart('a'), timestamp: 1 },
+          { ...opEnd('a'), timestamp: 2 },
+        ]),
+        makeMessage({ pid: 'op-new' }, [
+          { ...opStart('b'), timestamp: 3 },
+          { ...opEnd('b'), timestamp: 4 },
+        ]),
+      ],
+      { eventLimit: 2 },
+    );
+    expect(tree.children.map((child) => child.meta.pid)).toEqual(['op-new']);
+  });
+
+  test('flattenSpanTree returns root + all descendants in depth-first order', ({ expect }) => {
+    const tree = buildSpanTree([
+      makeMessage({ pid: 'agent-1' }, [{ ...agentBegin(), timestamp: 1 }]),
+      makeMessage({ pid: 'op-1', parentPid: 'agent-1' }, [
+        { ...opStart('a'), timestamp: 2 },
+        { ...opEnd('a'), timestamp: 3 },
+      ]),
+      makeMessage({ pid: 'agent-1' }, [{ ...agentEnd(), timestamp: 4 }]),
+    ]);
+    const order = flattenSpanTree(tree);
+    expect(order[0].id).toBe(ROOT_SPAN_ID);
+    expect(order[1].meta.pid).toBe('agent-1');
+    expect(order[2].meta.pid).toBe('op-1');
+    expect(order).toHaveLength(3);
+  });
+});

package/src/containers/TracePanel/span-tree.ts

@@ -0,0 +1,214 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { AgentRequestBegin, AgentRequestEnd } from '@dxos/assistant';
+import { Trace } from '@dxos/compute';
+
+/**
+ * Synthetic id assigned to the root span.
+ * The root is a virtual container for top-level spans (those without a parent in the captured trace).
+ */
+export const ROOT_SPAN_ID = '<main>';
+
+/**
+ * Computed metadata for a span.
+ * Derived from the meta of the begin event that opened the span.
+ */
+export interface SpanMeta {
+  readonly pid?: string;
+  readonly parentPid?: string;
+  readonly processName?: string;
+  readonly conversationId?: string;
+  readonly triggerId?: string;
+  readonly toolCallId?: string;
+  readonly runtimeName?: string;
+}
+
+/**
+ * A span in the trace hierarchy.
+ *
+ * Each span represents a single bounded unit of work — an operation invocation or an
+ * agent request. Spans are opened by `OperationStart` / `AgentRequestBegin` events and
+ * closed by their matching `OperationEnd` / `AgentRequestEnd` events. A single process
+ * (pid) may produce multiple sequential spans (for example, an agent session that serves
+ * three prompts produces three sibling spans sharing the agent's pid).
+ *
+ * `events` contains the bounded events for this span only — child spans' events are not
+ * duplicated here. `children` contains sub-spans that opened while this span was active.
+ */
+export interface Span {
+  readonly id: string;
+  readonly meta: SpanMeta;
+  readonly events: Trace.FlatEvent[];
+  readonly children: Span[];
+}
+
+export const BEGIN_EVENT_TYPES = new Set<string>([Trace.OperationStart.key, AgentRequestBegin.key]);
+export const END_EVENT_TYPES = new Set<string>([Trace.OperationEnd.key, AgentRequestEnd.key]);
+
+export const isSpanBeginEvent = (event: Trace.FlatEvent): boolean => BEGIN_EVENT_TYPES.has(event.type);
+export const isSpanEndEvent = (event: Trace.FlatEvent): boolean => END_EVENT_TYPES.has(event.type);
+
+const computeMeta = (rawMeta: Trace.Meta): SpanMeta => ({
+  pid: rawMeta.pid,
+  parentPid: rawMeta.parentPid,
+  processName: rawMeta.processName,
+  conversationId: rawMeta.conversationId,
+  triggerId: rawMeta.triggerId,
+  toolCallId: rawMeta.toolCallId,
+  runtimeName: rawMeta.runtimeName,
+});
+
+interface MutableSpan {
+  id: string;
+  meta: SpanMeta;
+  events: Trace.FlatEvent[];
+  children: MutableSpan[];
+  firstTimestamp: number;
+}
+
+const makeMutableSpan = (id: string, meta: SpanMeta): MutableSpan => ({
+  id,
+  meta,
+  events: [],
+  children: [],
+  firstTimestamp: Number.POSITIVE_INFINITY,
+});
+
+const freezeSpan = (span: MutableSpan): Span => ({
+  id: span.id,
+  meta: span.meta,
+  events: span.events,
+  children: span.children.map(freezeSpan),
+});
+
+export interface BuildSpanTreeOptions {
+  /**
+   * If provided, only the last `eventLimit` flat events (after flattening and chronological sort)
+   * are placed into the tree. Spans with no remaining events are dropped from the result.
+   */
+  eventLimit?: number;
+}
+
+/**
+ * Builds a hierarchical span tree from a list of trace messages.
+ *
+ * Algorithm:
+ *   1. Flatten messages into events and sort them chronologically.
+ *   2. For each event:
+ *      - Begin events (`OperationStart`, `AgentRequestBegin`) open a new span whose parent
+ *        is the currently-open span of the event's `meta.parentPid`, or the root if there is
+ *        none. The begin event itself becomes the first event of the new span.
+ *      - End events (`OperationEnd`, `AgentRequestEnd`) close the currently-open span for
+ *        the event's `meta.pid` and become its last event.
+ *      - Other events attach to the currently-open span for their `meta.pid`, or to the
+ *        root span if no span is currently open for that pid (or the event has no pid).
+ *   3. Sort each span's children by their earliest event timestamp.
+ */
+export const buildSpanTree = (messages: Trace.Message[], options: BuildSpanTreeOptions = {}): Span => {
+  const allEvents = messages.flatMap((message) => Trace.flatten(message));
+  allEvents.sort((a, b) => a.timestamp - b.timestamp);
+
+  const events =
+    options.eventLimit !== undefined && allEvents.length > options.eventLimit
+      ? allEvents.slice(-options.eventLimit)
+      : allEvents;
+
+  const root = makeMutableSpan(ROOT_SPAN_ID, {});
+
+  // Currently-open span for each pid.
+  // A process may host multiple sequential spans (e.g. successive agent requests), so we
+  // track the active one and start a new span on the next begin event.
+  const openSpans = new Map<string, MutableSpan>();
+
+  let spanCounter = 0;
+  const allocSpanId = (pid: string): string => {
+    const id = `${pid}#${spanCounter}`;
+    spanCounter += 1;
+    return id;
+  };
+
+  const noteTimestamp = (span: MutableSpan, timestamp: number): void => {
+    if (timestamp < span.firstTimestamp) {
+      span.firstTimestamp = timestamp;
+    }
+  };
+
+  for (const event of events) {
+    const pid = event.meta.pid;
+
+    if (!pid) {
+      // Events without a pid attach to the root.
+      root.events.push(event);
+      noteTimestamp(root, event.timestamp);
+      continue;
+    }
+
+    if (BEGIN_EVENT_TYPES.has(event.type)) {
+      const parentPid = event.meta.parentPid;
+      const parent = (parentPid && openSpans.get(parentPid)) || root;
+      const span = makeMutableSpan(allocSpanId(pid), computeMeta(event.meta));
+      span.events.push(event);
+      noteTimestamp(span, event.timestamp);
+      parent.children.push(span);
+      // The new span supersedes any previously-open span for this pid.
+      openSpans.set(pid, span);
+      continue;
+    }
+
+    if (END_EVENT_TYPES.has(event.type)) {
+      const span = openSpans.get(pid);
+      if (span) {
+        span.events.push(event);
+        noteTimestamp(span, event.timestamp);
+        openSpans.delete(pid);
+      } else {
+        // End event without a matching begin — attach to root so the event isn't lost.
+        root.events.push(event);
+        noteTimestamp(root, event.timestamp);
+      }
+      continue;
+    }
+
+    // Non-boundary event: attach to the currently-open span for this pid if any.
+    const open = openSpans.get(pid);
+    if (open) {
+      open.events.push(event);
+      noteTimestamp(open, event.timestamp);
+    } else {
+      root.events.push(event);
+      noteTimestamp(root, event.timestamp);
+    }
+  }
+
+  // Sort children chronologically for deterministic output.
+  const sortChildren = (span: MutableSpan): void => {
+    span.children.sort((a, b) => a.firstTimestamp - b.firstTimestamp);
+    for (const child of span.children) {
+      sortChildren(child);
+    }
+  };
+  sortChildren(root);
+
+  return freezeSpan(root);
+};
+
+/**
+ * Walks the span tree in depth-first pre-order, invoking `visit` for each span (root included).
+ */
+export const walkSpanTree = (root: Span, visit: (span: Span, depth: number) => void, depth = 0): void => {
+  visit(root, depth);
+  for (const child of root.children) {
+    walkSpanTree(child, visit, depth + 1);
+  }
+};
+
+/**
+ * Returns all spans in the tree in depth-first pre-order, root first.
+ */
+export const flattenSpanTree = (root: Span): Span[] => {
+  const result: Span[] = [];
+  walkSpanTree(root, (span) => result.push(span));
+  return result;
+};

package/src/containers/index.ts

@@ -4,12 +4,13 @@
 
 import { type ComponentType, lazy } from 'react';
 
+export const AgentArticle: ComponentType<any> = lazy(() => import('./AgentArticle'));
+export const AgentProperties: ComponentType<any> = lazy(() => import('./AgentProperties'));
 export const BlueprintArticle: ComponentType<any> = lazy(() => import('./BlueprintArticle'));
 export const ChatCompanion: ComponentType<any> = lazy(() => import('./ChatCompanion'));
-export const ChatContainer: ComponentType<any> = lazy(() => import('./ChatContainer'));
+export const ChatArticle: ComponentType<any> = lazy(() => import('./ChatArticle'));
 export const ChatDialog: ComponentType<any> = lazy(() => import('./ChatDialog'));
-export const AgentArticle: ComponentType<any> = lazy(() => import('./AgentArticle'));
-export const AgentProperties: ComponentType<any> = lazy(() => import('./AgentProperties'));
+export const PlanArticle: ComponentType<any> = lazy(() => import('./PlanArticle'));
 export const RoutineArticle: ComponentType<any> = lazy(() => import('./RoutineArticle'));
 export const RoutineList: ComponentType<any> = lazy(() => import('./RoutineList'));
 export const TracePanel: ComponentType<any> = lazy(() => import('./TracePanel'));

package/src/{queue-logger.ts → feed-logger.ts}

@@ -2,62 +2,63 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Queue, Ref, type Space, getSpace } from '@dxos/client/echo';
-import { type Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
-import { DXN, Feed, Obj } from '@dxos/echo';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { createFeedServiceLayer, type Space, getSpace } from '@dxos/client/echo';
+import { Sequence, type SequenceEvent, type SequenceLogger } from '@dxos/conductor';
+import { DXN, Feed, Obj, Ref } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
 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';
 
-export class QueueLogger implements SequenceLogger {
+export class FeedLogger implements SequenceLogger {
   private _space: Space;
-  private _invocationTraceQueue: Queue<InvocationTraceEvent>;
+  private _invocationTraceFeed: Feed.Feed;
+  private _feedServiceLayer: Layer.Layer<Feed.FeedService>;
 
-  constructor(private readonly sequence: Sequence) {
+  constructor(private readonly sequence: Sequence.Sequence) {
     const space = getSpace(sequence);
     invariant(space, 'Space not found');
     this._space = space;
+    this._feedServiceLayer = createFeedServiceLayer(space.queues);
 
     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.
+      // A feed reference exists; ensure its target is loaded. If not, 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');
+      invariant(Feed.getQueueDxn(existingFeedRef.target), 'invocationTraceFeed has no DXN');
+      this._invocationTraceFeed = existingFeedRef.target;
     } else {
       const feed = space.db.add(Feed.make({ namespace: 'trace' }));
-      queueDxn = Feed.getQueueDxn(feed) ?? undefined;
-      invariant(queueDxn, 'New invocationTraceFeed has no queue DXN');
+      invariant(Feed.getQueueDxn(feed), 'New invocationTraceFeed has no DXN');
       Obj.update(this._space.properties, (obj) => {
         obj.invocationTraceFeed = Ref.make(feed);
       });
+      this._invocationTraceFeed = feed;
     }
-
-    this._invocationTraceQueue = this._space.queues.get(queueDxn);
   }
 
   log(event: SequenceEvent) {
     switch (event.type) {
       case 'begin':
-        void this._invocationTraceQueue.append([
+        void this._appendToTraceFeed([
           Obj.make(InvocationTraceStartEvent, {
             type: InvocationTraceEventType.START,
             invocationId: event.invocationId,
             timestamp: Date.now(),
             input: {},
-            invocationTraceQueue: Ref.fromDXN(this._getTraceQueueDxn(event.invocationId)),
+            invocationTraceFeed: Ref.fromDXN(this._getTraceFeedDXN(event.invocationId)),
             invocationTarget: Ref.make(this.sequence),
           }),
         ]);
         break;
       case 'end':
-        void this._invocationTraceQueue.append([
+        void this._appendToTraceFeed([
           Obj.make(InvocationTraceEndEvent, {
             type: InvocationTraceEventType.END,
             invocationId: event.invocationId,
@@ -68,7 +69,7 @@ export class QueueLogger implements SequenceLogger {
         break;
       case 'step-start':
       case 'step-complete':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendTraceEvent(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -86,7 +87,7 @@ export class QueueLogger implements SequenceLogger {
         ]);
         break;
       case 'message':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendTraceEvent(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -104,7 +105,7 @@ export class QueueLogger implements SequenceLogger {
         ]);
         break;
       case 'block':
-        void this._getTraceEventQueue(event.invocationId).append([
+        void this._appendTraceEvent(event.invocationId, [
           Obj.make(TraceEvent, {
             outcome: event.type,
             truncated: false,
@@ -124,12 +125,21 @@ export class QueueLogger implements SequenceLogger {
     }
   }
 
-  private _getTraceQueueDxn(invocationId: string): DXN {
+  private _getTraceFeedDXN(invocationId: string): DXN {
     return DXN.fromQueue(QueueSubspaceTags.TRACE, this._space.id, invocationId);
   }
 
-  private _getTraceEventQueue(invocationId: string): Queue<TraceEvent> {
-    const dxn = this._getTraceQueueDxn(invocationId);
-    return this._space.queues.get(dxn);
+  private _appendToTraceFeed(items: any[]): Promise<void> {
+    return Feed.append(this._invocationTraceFeed, items).pipe(
+      Effect.provide(this._feedServiceLayer),
+      runAndForwardErrors,
+    );
   }
+
+  /**
+   * Per-invocation trace event feeds are deprecated and no longer functional;
+   * this is a no-op until a replacement tracing data structure lands.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private async _appendTraceEvent(_invocationId: string, _items: TraceEvent[]): Promise<void> {}
 }

package/src/hooks/useBlueprintRegistry.ts

@@ -6,7 +6,7 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 
 import { useCapabilities } from '@dxos/app-framework/ui';
 import { AppCapabilities } from '@dxos/app-toolkit';
-import { type AiContextBinder } from '@dxos/assistant';
+import { type AiContext } from '@dxos/assistant';
 import { Blueprint } from '@dxos/compute';
 import { type Database, Filter, Obj, Ref } from '@dxos/echo';
 import { useQuery } from '@dxos/react-client/echo';
@@ -35,7 +35,7 @@ export const useBlueprints = ({
   const staticBlueprints = useMemo(() => blueprintRegistry?.query() ?? [], [blueprintRegistry]);
   const spaceBlueprints = useQuery(db, Filter.type(Blueprint.Blueprint));
   return useMemo(() => {
-    const blueprints = distinctBy([...staticBlueprints, ...spaceBlueprints], (b) => b.key);
+    const blueprints = distinctBy([...staticBlueprints, ...spaceBlueprints], (b) => Obj.getMeta(b).key);
     blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
     return blueprints;
   }, [staticBlueprints, spaceBlueprints]);
@@ -44,7 +44,7 @@ export const useBlueprints = ({
 /**
  * Create reactive map of active blueprints (by key).
  */
-export const useActiveBlueprints = ({ context }: { context?: AiContextBinder }) => {
+export const useActiveBlueprints = ({ context }: { context?: AiContext.Binder }) => {
   const [active, setActive] = useState<Map<string, Blueprint.Blueprint>>(new Map());
 
   useEffect(() => {
@@ -55,7 +55,13 @@ export const useActiveBlueprints = ({ context }: { context?: AiContextBinder })
 
     const updateActive = () => {
       const blueprints = context.getBlueprints();
-      setActive(new Map(blueprints.map((blueprint) => [blueprint.key, blueprint])));
+      setActive(
+        new Map(
+          blueprints
+            .map((blueprint) => [Obj.getMeta(blueprint).key, blueprint] as const)
+            .filter((entry): entry is readonly [string, Blueprint.Blueprint] => entry[0] !== undefined),
+        ),
+      );
     };
 
     // Set initial value.
@@ -75,7 +81,7 @@ export const useBlueprintHandlers = ({
   blueprintRegistry,
 }: {
   db: Database.Database;
-  context?: AiContextBinder;
+  context?: AiContext.Binder;
   blueprintRegistry?: Blueprint.Registry;
 }) => {
   const onUpdateBlueprint = useCallback(
@@ -86,7 +92,7 @@ export const useBlueprintHandlers = ({
 
       // Find existing cloned blueprint.
       const objects = await db.query(Filter.type(Blueprint.Blueprint)).run();
-      let storedBlueprint = objects.find((blueprint) => blueprint.key === key);
+      let storedBlueprint = objects.find((blueprint) => Obj.getMeta(blueprint).key === key);
       if (checked) {
         if (!storedBlueprint) {
           const blueprint = blueprintRegistry.getByKey(key);

package/src/hooks/useChatProcessor.ts

@@ -13,7 +13,7 @@ import { Feed, Ref } from '@dxos/echo';
 import { createFeedServiceLayer } from '@dxos/echo-db';
 import { runAndForwardErrors } from '@dxos/effect';
 import { log } from '@dxos/log';
-import { type AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { type AutomationCapabilities } from '@dxos/plugin-automation';
 import { type Space } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 
@@ -43,7 +43,7 @@ export const useChatProcessor = ({
 }: UseChatProcessorProps): AiChatProcessor | undefined => {
   const observableRegistry = useContext(RegistryContext);
 
-  const [session, setSession] = useState<AiSession>();
+  const [session, setSession] = useState<AiSession.Session>();
   useAsyncEffect(async () => {
     if (!space || !chat) {
       return;
@@ -57,7 +57,7 @@ export const useChatProcessor = ({
     const runtime = await runAndForwardErrors(
       Effect.runtime<Feed.FeedService>().pipe(Effect.provide(feedServiceLayer)),
     );
-    const session = new AiSession({
+    const session = new AiSession.Session({
       feed: feedTarget,
       runtime,
       registry: observableRegistry as Registry.Registry,

package/src/hooks/useChatServices.ts

@@ -7,7 +7,7 @@ import { useMemo } from 'react';
 import { useCapability } from '@dxos/app-framework/ui';
 import { getPersonalSpace } from '@dxos/app-toolkit';
 import { type Key } from '@dxos/echo';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
 import { useClient } from '@dxos/react-client';
 
 export type UseChatServicesProps = {