@dxos/plugin-assistant 0.8.4-main.7996785055 → 0.8.4-main.8baae0fced

package/src/blueprints/assistant/{blueprint.test.ts → blueprint.node.test.ts}

@@ -2,16 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { describe, expect, it } from '@effect/vitest';
+import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
 
-import { AiConversationService } from '@dxos/assistant';
-import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { DatabaseBlueprint, DatabaseHandlers } from '@dxos/assistant-toolkit';
-import { addBlueprints } from '@dxos/assistant-toolkit/testing';
-import { Blueprint } from '@dxos/blueprints';
+import { Blueprint } from '@dxos/compute';
+import { Feed } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
+import { AgentService } from '@dxos/functions-runtime';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
 import { ObjectId } from '@dxos/keys';
 import { Organization } from '@dxos/types';
 
@@ -20,27 +19,26 @@ import AssistantBlueprint from './blueprint';
 ObjectId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayer({
+  aiServicePreset: 'edge-remote',
   operationHandlers: DatabaseHandlers,
-  types: [Organization.Organization, Blueprint.Blueprint],
+  types: [Organization.Organization, Blueprint.Blueprint, Feed.Feed],
+  blueprints: [AssistantBlueprint.make(), DatabaseBlueprint.make()],
   tracing: 'pretty',
 });
 
-const provideTestLayers = Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer)));
-
 describe('Assistant Blueprint', () => {
   // TODO(dmaretskyi): Regenerate memoized conversation with ALLOW_LLM_GENERATION=1.
   it.effect.skip(
     'works with Database blueprint to create objects',
     Effect.fnUntraced(
       function* (_) {
-        yield* addBlueprints([AssistantBlueprint, DatabaseBlueprint]);
-        const messages = yield* AiConversationService.run({
-          prompt: 'Create a new organization called "Test Corp".',
+        const agent = yield* AgentService.createSession({
+          blueprints: [AssistantBlueprint.make(), DatabaseBlueprint.make()],
         });
-        const lastMessage = messages.at(-1);
-        expect(lastMessage).toBeDefined();
+        yield* agent.submitPrompt('Create a new organization called "Test Corp".');
+        yield* agent.waitForCompletion();
       },
-      provideTestLayers,
+      Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
     ),
     { timeout: 60_000 },

package/src/blueprints/assistant/blueprint.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { LayoutOperation, type AppCapabilities } from '@dxos/app-toolkit';
+import { LayoutOperation } from '@dxos/app-toolkit';
 import { templates } from '@dxos/assistant';
-import { Blueprint } from '@dxos/blueprints';
+import { Blueprint } from '@dxos/compute';
 
-import { AssistantOperation } from '../../operations';
+import { AssistantOperation } from '#types';
 
 const BLUEPRINT_KEY = 'org.dxos.blueprint.assistant';
 
@@ -23,7 +23,7 @@ const make = () =>
     instructions: templates.system,
   });
 
-const blueprint: AppCapabilities.BlueprintDefinition = {
+const blueprint: Blueprint.Definition = {
   key: BLUEPRINT_KEY,
   make,
 };

package/src/capabilities/ai-service.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { AiModelResolver, AiService } from '@dxos/ai';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { LayerSpec } from '@dxos/compute';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const resolvers = yield* Capability.getAll(AppCapabilities.AiModelResolver);
+
+    // TODO(dmaretskyi): Extract function to reduce them.
+    const combinedLayer = resolvers.reduce(
+      (acc, resolver) => resolver.pipe(Layer.provide(acc)),
+      AiModelResolver.AiModelResolver.fromModelMap({ name: 'Fallback' }, Effect.succeed({})), // Empty resolver as fallback.
+    );
+
+    const aiServiceLayer: Layer.Layer<AiService.AiService> = AiModelResolver.AiModelResolver.buildAiService.pipe(
+      Layer.provide(combinedLayer),
+    );
+
+    const aiServiceSpec = LayerSpec.make(
+      {
+        affinity: 'application',
+        requires: [],
+        provides: [AiService.AiService],
+      },
+      () => aiServiceLayer,
+    );
+
+    return [
+      // Deprecated: `AppCapabilities.AiServiceLayer` is retained for non-process-manager
+      // call sites (e.g. legacy CLI paths). New consumers should resolve `AiService.AiService`
+      // through the process manager runtime via the `LayerSpec` contribution below.
+      Capability.contributes(AppCapabilities.AiServiceLayer, aiServiceLayer),
+      Capability.contributes(Capabilities.LayerSpec, aiServiceSpec),
+    ];
+  }),
+);

package/src/capabilities/app-graph-builder.ts

@@ -0,0 +1,197 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
+import * as Option from 'effect/Option';
+
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities, AppNode, getActiveSpace, getPersonalSpace } from '@dxos/app-toolkit';
+import { AgentPrompt, Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Operation, Routine } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { DXN, Database, Filter, Obj, type Ref } from '@dxos/echo';
+import { AtomObj } from '@dxos/echo-atom';
+import { invariant } from '@dxos/invariant';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
+import { linkedSegment } from '@dxos/react-ui-attention';
+
+import { ASSISTANT_COMPANION_VARIANT, meta } from '#meta';
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+/** Operation definitions to seed as `PersistentOperation` records for automation / triggers. */
+const computeOperationsToImport = [AgentPrompt] as const;
+
+/** Match ECHO objects that are NOT chats. */
+const whenNonChatObject = NodeMatcher.whenAll(
+  NodeMatcher.whenEchoObject,
+  NodeMatcher.whenNot(NodeMatcher.whenEchoTypeMatches(Chat.Chat)),
+);
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilities = yield* Capability.Service;
+
+    const extensions = yield* Effect.all([
+      GraphBuilder.createTypeExtension({
+        id: 'root',
+        type: Chat.Chat,
+        actions: (chat) => {
+          return Effect.succeed([
+            Node.makeAction({
+              id: AssistantOperation.UpdateChatName.meta.key,
+              data: () =>
+                Effect.gen(function* () {
+                  // TODO(dmaretskyi): This goes away when composer will have unified operation invocations.
+                  const db = Obj.getDatabase(chat);
+                  invariant(db);
+                  yield* Operation.invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId: db.spaceId });
+                }),
+              properties: {
+                label: ['chat-update-name.label', { ns: meta.id }],
+                icon: 'ph--magic-wand--regular',
+                disposition: 'list-item',
+              },
+            }),
+          ]);
+        },
+      }),
+
+      GraphBuilder.createExtension({
+        id: 'assistant',
+        match: NodeMatcher.whenRoot,
+        actions: () =>
+          Effect.succeed([
+            Node.makeAction({
+              id: 'import-compute-operations',
+              data: Effect.fnUntraced(function* () {
+                const capabilities = yield* Capability.Service;
+                const client = yield* Capability.get(ClientCapabilities.Client);
+                const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+                if (!space) {
+                  return;
+                }
+                for (const definition of computeOperationsToImport) {
+                  const key = definition.meta.key;
+                  if (!key) {
+                    continue;
+                  }
+                  const existing = yield* Effect.promise(
+                    (): Promise<Operation.PersistentOperation[]> =>
+                      space.db.query(Filter.and(Filter.type(Operation.PersistentOperation), Filter.key(key))).run(),
+                  );
+                  if (existing.length === 0) {
+                    space.db.add(Operation.serialize(definition));
+                  }
+                }
+                yield* Database.flush();
+              }),
+              properties: {
+                label: ['import-compute-operations.label', { ns: meta.id }],
+                icon: 'ph--download-simple--regular',
+              },
+            }),
+            Node.makeAction({
+              id: AssistantOperation.ToggleTracePanelDebug.meta.key,
+              data: () => Operation.invoke(AssistantOperation.ToggleTracePanelDebug, {}),
+              properties: {
+                label: ['toggle-trace-panel-debug.label', { ns: meta.id }],
+                icon: 'ph--brackets-curly--regular',
+              },
+            }),
+            Node.makeAction({
+              id: 'reset-blueprints',
+              data: Effect.fnUntraced(function* () {
+                const capabilities = yield* Capability.Service;
+                const client = yield* Capability.get(ClientCapabilities.Client);
+                const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+                if (!space) {
+                  return;
+                }
+                const blueprints = yield* Effect.promise(
+                  (): Promise<Blueprint.Blueprint[]> => space.db.query(Filter.type(Blueprint.Blueprint)).run(),
+                );
+                for (const blueprint of blueprints) {
+                  space.db.remove(blueprint);
+                }
+                yield* Database.flush();
+              }),
+              properties: {
+                label: ['reset-blueprints.label', { ns: meta.id }],
+                icon: 'ph--arrow-clockwise--regular',
+              },
+            }),
+          ]),
+      }),
+
+      // Don't show assistant companion when a chat is already the primary object.
+      GraphBuilder.createExtension({
+        id: 'companion-chat',
+        match: whenNonChatObject,
+        connector: (object, get) =>
+          Effect.gen(function* () {
+            const state = get(yield* Capability.get(AssistantCapabilities.State));
+            const cache = get(yield* Capability.get(AssistantCapabilities.CompanionChatCache));
+            const objectDXN = Obj.getDXN(object).toString();
+
+            // Resolve chat from persisted state or transient cache.
+            const chat = pipe(
+              Option.fromNullable(state.currentChat[objectDXN]),
+              Option.flatMap((dxnStr) => Option.fromNullable(DXN.tryParse(dxnStr))),
+              Option.flatMap((dxn) => Option.fromNullable(Obj.getDatabase(object)?.makeRef(dxn))),
+              Option.map((ref) => get(AtomObj.make(ref as Ref.Ref<Obj.Unknown>))),
+              Option.filter(Obj.isObject),
+              Option.orElse(() => pipe(Option.fromNullable(cache[objectDXN]), Option.filter(Obj.isObject))),
+              Option.getOrNull,
+            );
+
+            return [
+              AppNode.makeCompanion({
+                id: linkedSegment(ASSISTANT_COMPANION_VARIANT),
+                label: ['assistant-chat.label', { ns: meta.id }],
+                icon: 'ph--sparkle--regular',
+                data: chat,
+                position: 'first',
+              }),
+            ];
+          }),
+      }),
+
+      GraphBuilder.createExtension({
+        id: 'invocations',
+        match: NodeMatcher.whenAny(
+          NodeMatcher.whenEchoTypeMatches(Sequence.Sequence),
+          NodeMatcher.whenEchoTypeMatches(Routine.Routine),
+        ),
+        connector: () =>
+          Effect.succeed([
+            AppNode.makeCompanion({
+              id: 'invocations',
+              label: ['invocations.label', { ns: meta.id }],
+              icon: 'ph--clock-countdown--regular',
+              data: 'invocations',
+            }),
+          ]),
+      }),
+
+      GraphBuilder.createExtension({
+        id: 'trace',
+        match: NodeMatcher.whenRoot,
+        connector: () =>
+          Effect.succeed([
+            AppNode.makeDeckCompanion({
+              id: linkedSegment('trace'),
+              label: ['trace.label', { ns: meta.id }],
+              icon: 'ph--line-segments--regular',
+              data: 'trace' as const,
+              position: 'last',
+            }),
+          ]),
+      }),
+    ]);
+
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/{blueprint-definition/blueprint-definition.ts → blueprint-definition.ts}

@@ -7,27 +7,27 @@ import * as Effect from 'effect/Effect';
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
 import {
+  AgentBlueprint,
+  AgentBlueprintHandlers,
   AgentHandlers,
+  AgentWizardBlueprint,
+  AgentWizardHandlers,
   BlueprintManagerBlueprint,
   BlueprintManagerHandlers,
   BrowserBlueprint,
   DatabaseBlueprint,
   DatabaseHandlers,
   DiscordBlueprint,
-  EntityExtractionHandlers,
   LinearBlueprint,
   PlanningBlueprint,
-  ProjectBlueprint,
-  ProjectHandlers,
-  ProjectWizardBlueprint,
-  ProjectWizardHandlers,
-  ResearchBlueprint,
   WebSearchBlueprint,
   MemoryBlueprint,
   AutomationBlueprint,
 } from '@dxos/assistant-toolkit';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Blueprint } from '@dxos/compute';
 
-import { AssistantBlueprint } from '../../blueprints';
+import { AssistantBlueprint } from '#blueprints';
 
 // TODO(dmaretskyi): Force this type for all Capability.makeModule calls.
 const blueprintDefinition: () => Effect.Effect<Capability.Capability<unknown>[]> = Capability.makeModule(() =>
@@ -35,23 +35,21 @@ const blueprintDefinition: () => Effect.Effect<Capability.Capability<unknown>[]>
     Capability.contributes(AppCapabilities.BlueprintDefinition, AssistantBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, BrowserBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, DatabaseBlueprint),
-    Capability.contributes(AppCapabilities.BlueprintDefinition, ResearchBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, WebSearchBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, DiscordBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, LinearBlueprint),
-    Capability.contributes(AppCapabilities.BlueprintDefinition, ProjectBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, AgentBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, PlanningBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, MemoryBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, AutomationBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, BlueprintManagerBlueprint),
-    Capability.contributes(AppCapabilities.BlueprintDefinition, ProjectWizardBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, AgentWizardBlueprint),
 
     Capability.contributes(Capabilities.OperationHandler, AgentHandlers),
+    Capability.contributes(Capabilities.OperationHandler, AgentBlueprintHandlers),
     Capability.contributes(Capabilities.OperationHandler, BlueprintManagerHandlers),
     Capability.contributes(Capabilities.OperationHandler, DatabaseHandlers),
-    Capability.contributes(Capabilities.OperationHandler, EntityExtractionHandlers),
-    Capability.contributes(Capabilities.OperationHandler, ProjectHandlers),
-    Capability.contributes(Capabilities.OperationHandler, ProjectWizardHandlers),
+    Capability.contributes(Capabilities.OperationHandler, AgentWizardHandlers),
   ]),
 );
 

package/src/capabilities/companion-chat-provisioner.ts

@@ -0,0 +1,163 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Registry } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Graph, type Node } from '@dxos/app-graph';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { DeckCapabilities, PLANK_COMPANION_TYPE, type StoredDeckState } from '@dxos/plugin-deck';
+import { getLinkedVariant } from '@dxos/react-ui-attention';
+import { byPosition } from '@dxos/util';
+
+import { ASSISTANT_COMPANION_VARIANT } from '#meta';
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+/**
+ * Non-React capability that watches deck companion state and provisions transient chats
+ * for active planks when the assistant companion is selected.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
+    const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+    const registry: Registry.Registry = yield* Capability.get(Capabilities.AtomRegistry);
+    const deckStateAtom = yield* Capability.get(DeckCapabilities.State);
+    const cacheAtom = yield* Capability.get(AssistantCapabilities.CompanionChatCache);
+    const stateAtom = yield* Capability.get(AssistantCapabilities.State);
+
+    const plankSubs = new Map<string, () => void>();
+
+    /** Unsubscribe a single plank and remove it from the map. */
+    const unsubPlank = (plankId: string) => {
+      plankSubs.get(plankId)?.();
+      plankSubs.delete(plankId);
+    };
+
+    /** Unsubscribe all per-plank subscriptions. */
+    const unsubAllPlanks = () => {
+      for (const unsub of plankSubs.values()) {
+        unsub();
+      }
+      plankSubs.clear();
+    };
+
+    /**
+     * Attempt to provision for a single plank.
+     * Returns true when the plank is resolved (provisioned or already cached)
+     * so the caller can tear down the connection subscription.
+     */
+    const provisionForPlank = (plankId: string, companionVariant: string | undefined): boolean => {
+      const node: Node.Node | null = Graph.getNode(graph, plankId).pipe(Option.getOrNull);
+      if (!node || !Obj.isObject(node.data) || Obj.instanceOf(Chat.Chat, node.data)) {
+        return false;
+      }
+
+      if (resolveEffectiveVariant(graph, plankId, companionVariant) !== ASSISTANT_COMPANION_VARIANT) {
+        return false;
+      }
+
+      const object = node.data;
+      const companionDXN = Obj.getDXN(object).toString();
+      const cache = registry.get(cacheAtom);
+      if (cache[companionDXN]) {
+        return true;
+      }
+
+      const db = Obj.getDatabase(object);
+      if (!db) {
+        return false;
+      }
+
+      void operationInvoker
+        .invokePromise(AssistantOperation.EnsureCompanionChat, { db, companionTo: object })
+        .catch((error) => log.warn('Failed to provision companion chat', { plankId, error }));
+
+      return false;
+    };
+
+    const provision = () => {
+      const deckState: StoredDeckState = registry.get(deckStateAtom);
+      const deck = deckState.decks[deckState.activeDeck];
+      if (!deck?.companionOpen) {
+        unsubAllPlanks();
+        return;
+      }
+
+      const plankIds = new Set(deck.solo ? [deck.solo] : deck.active);
+
+      // Remove subscriptions for planks that are no longer active.
+      for (const trackedId of plankSubs.keys()) {
+        if (!plankIds.has(trackedId)) {
+          unsubPlank(trackedId);
+        }
+      }
+
+      for (const plankId of plankIds) {
+        const resolved = provisionForPlank(plankId, deck.companionVariant);
+
+        if (resolved) {
+          // Already provisioned — no need to watch connections.
+          unsubPlank(plankId);
+        } else if (!plankSubs.has(plankId)) {
+          // Not yet resolved — subscribe to child connections so we re-try
+          // when graph builder extensions add companion nodes (after expand).
+          plankSubs.set(
+            plankId,
+            registry.subscribe(graph.connections(plankId, 'child'), () => {
+              if (provisionForPlank(plankId, deck.companionVariant)) {
+                unsubPlank(plankId);
+              }
+            }),
+          );
+        }
+      }
+    };
+
+    provision();
+
+    const unsub1 = registry.subscribe(deckStateAtom, provision);
+    const unsub2 = registry.subscribe(stateAtom, provision);
+
+    return Capability.contributes(Capabilities.Null, null, () =>
+      Effect.sync(() => {
+        unsub1();
+        unsub2();
+        unsubAllPlanks();
+      }),
+    );
+  }),
+);
+
+/**
+ * Mirrors useSelectedCompanion fallback logic outside of React.
+ * Returns the variant that would actually be rendered for a given plank.
+ */
+const resolveEffectiveVariant = (
+  graph: Graph.BaseGraph,
+  plankId: string,
+  preferredVariant: string | undefined,
+): string | undefined => {
+  const companions = Graph.getConnections(graph, plankId, 'child')
+    .filter((node) => node.type === PLANK_COMPANION_TYPE)
+    .toSorted((a, b) => byPosition(a.properties, b.properties));
+
+  if (companions.length === 0) {
+    return undefined;
+  }
+
+  if (preferredVariant) {
+    const preferred = companions.find((companion) => getLinkedVariant(companion.id) === preferredVariant);
+    if (preferred) {
+      return getLinkedVariant(preferred.id);
+    }
+  }
+
+  return getLinkedVariant(companions[0].id);
+};

package/src/capabilities/create-object.ts

@@ -0,0 +1,102 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { Capability, Capabilities } from '@dxos/app-framework';
+import { Agent, AgentBlueprint, Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Operation, Routine, ServiceResolver } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { Database, Feed, Obj } from '@dxos/echo';
+import { QueueService } from '@dxos/functions';
+import { SpaceCapabilities, SpaceOperation } from '@dxos/plugin-space';
+
+import { AssistantOperation } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Chat.Chat.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const { object } = yield* Operation.invoke(AssistantOperation.CreateChat, {
+              db: options.db,
+              name: props?.name,
+            });
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Blueprint.Blueprint.typename,
+        inputSchema: AssistantOperation.BlueprintForm,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Blueprint.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Routine.Routine.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Routine.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Sequence.Sequence.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Obj.make(Sequence.Sequence, props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Agent.Agent.typename,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = yield* Agent.makeInitialized({ name: '', instructions: '' }, AgentBlueprint.make());
+
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }).pipe(
+            Effect.provide(
+              ServiceResolver.provide(
+                { space: options.db.spaceId },
+                Database.Service,
+                Feed.FeedService,
+                QueueService,
+              ).pipe(Layer.provide(Capability.asLayer(Capabilities.ServiceResolver, ServiceResolver.ServiceResolver))),
+            ),
+          ),
+      }),
+    ];
+  }),
+);