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

package/src/AssistantPlugin.tsx

@@ -3,95 +3,181 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 
-import { Capability, Common, Plugin } from '@dxos/app-framework';
-import { ResearchGraph } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt } from '@dxos/blueprints';
+import { ActivationEvent, ActivationEvents, Capability, Plugin } from '@dxos/app-framework';
+import { AppActivationEvents, AppPlugin } from '@dxos/app-toolkit';
+import { ContextBinding } from '@dxos/assistant';
+import { Agent, AgentBlueprint, Chat, McpServer, Memory, Plan } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
 import { Sequence } from '@dxos/conductor';
-import { Obj, Type } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
+import { Annotation, Feed, Obj, Type } from '@dxos/echo';
+import { type SpaceId } from '@dxos/keys';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
 import { ClientEvents } from '@dxos/plugin-client/types';
-import { SpaceCapabilities, SpaceEvents } from '@dxos/plugin-space/types';
-import { type CreateObject } from '@dxos/plugin-space/types';
-import { HasSubject } from '@dxos/types';
+import { DeckEvents } from '@dxos/plugin-deck/types';
+import { MarkdownEvents } from '@dxos/plugin-markdown/types';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { type CreateObject, SpaceCapabilities, SpaceEvents } from '@dxos/plugin-space/types';
+import { Text } from '@dxos/schema';
+import { HasSubject, Message } from '@dxos/types';
 
 import {
   AiService,
   AppGraphBuilder,
   AssistantState,
   BlueprintDefinition,
+  CompanionChatProvisioner,
   EdgeModelResolver,
   LocalModelResolver,
-  OperationResolver,
+  MarkdownExtension,
+  Migrations,
+  OperationHandler,
   ReactSurface,
-  Repair,
   Settings,
   Toolkit,
-} from './capabilities';
-import { meta } from './meta';
-import { translations } from './translations';
-import { AssistantEvents } from './types';
-import { Assistant, AssistantOperation } from './types';
+} from '#capabilities';
+import { meta } from '#meta';
+import { AssistantOperation } from '#operations';
+import { translations } from '#translations';
+import { AssistantEvents } from '#types';
 
 export const AssistantPlugin = Plugin.define(meta).pipe(
-  Common.Plugin.addTranslationsModule({ translations }),
-  Common.Plugin.addSettingsModule({ activate: Settings }),
-  Plugin.addModule({
-    // TODO(wittjosiah): Does not integrate with settings store.
-    //   Should this be a different event?
-    //   Should settings store be renamed to be more generic?
-    activatesOn: Common.ActivationEvent.SetupSettings,
-    activate: AssistantState,
-  }),
-  Common.Plugin.addMetadataModule({
+  AppPlugin.addAppGraphModule({ activate: AppGraphBuilder }),
+  AppPlugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),
+  AppPlugin.addMetadataModule({
     metadata: [
       {
-        id: Type.getTypename(Assistant.Chat),
+        id: Type.getTypename(Chat.Chat),
         metadata: {
-          icon: 'ph--atom--regular',
-          iconHue: 'sky',
-          createObject: ((props) => Effect.sync(() => Assistant.make(props))) satisfies CreateObject,
+          icon: Annotation.IconAnnotation.get(Chat.Chat).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Chat.Chat).pipe(Option.getOrThrow).hue ?? 'white',
+          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,
+              });
+            })) satisfies CreateObject,
         },
       },
       {
         id: Type.getTypename(Blueprint.Blueprint),
         metadata: {
-          icon: 'ph--blueprint--regular',
-          iconHue: 'sky',
+          icon: Annotation.IconAnnotation.get(Blueprint.Blueprint).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Blueprint.Blueprint).pipe(Option.getOrThrow).hue ?? 'white',
           inputSchema: AssistantOperation.BlueprintForm,
-          createObject: ((props) => Effect.sync(() => Blueprint.make(props))) satisfies CreateObject,
+          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,
+              });
+            })) satisfies CreateObject,
         },
       },
       {
-        id: Type.getTypename(Prompt.Prompt),
+        id: Type.getTypename(Routine.Routine),
         metadata: {
-          icon: 'ph--scroll--regular',
-          iconHue: 'sky',
-          createObject: ((props) => Effect.sync(() => Prompt.make(props))) satisfies CreateObject,
+          icon: Annotation.IconAnnotation.get(Routine.Routine).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Routine.Routine).pipe(Option.getOrThrow).hue ?? 'white',
+          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,
+              });
+            })) satisfies CreateObject,
         },
       },
       {
         id: Type.getTypename(Sequence),
         metadata: {
-          icon: 'ph--circuitry--regular',
-          iconHue: 'sky',
-          createObject: ((props) => Effect.sync(() => Obj.make(Sequence, props))) satisfies CreateObject,
-          addToCollectionOnCreate: true,
+          icon: Annotation.IconAnnotation.get(Sequence).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Sequence).pipe(Option.getOrThrow).hue ?? 'white',
+          createObject: ((props, options) =>
+            Effect.gen(function* () {
+              const object = Obj.make(Sequence, props);
+              return yield* Operation.invoke(SpaceOperation.AddObject, {
+                object,
+                target: options.target,
+                hidden: true,
+                targetNodeId: options.targetNodeId,
+              });
+            })) satisfies CreateObject,
+        },
+      },
+      {
+        id: Type.getTypename(Agent.Agent),
+        metadata: {
+          icon: Annotation.IconAnnotation.get(Agent.Agent).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Agent.Agent).pipe(Option.getOrThrow).hue ?? 'white',
+          createObject: ((props, options) =>
+            Effect.gen(function* () {
+              const object = yield* Agent.makeInitialized({ name: '', instructions: '' }, AgentBlueprint.make()).pipe(
+                withComputeRuntime(options.db.spaceId),
+              );
+              return yield* Operation.invoke(SpaceOperation.AddObject, {
+                object,
+                target: options.target,
+                hidden: true,
+                targetNodeId: options.targetNodeId,
+              });
+            })) satisfies CreateObject,
         },
       },
     ],
   }),
-  Common.Plugin.addSchemaModule({
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
     schema: [
-      Assistant.Chat,
-      Assistant.CompanionTo,
+      Chat.Chat,
+      Chat.CompanionTo,
       Blueprint.Blueprint,
+      ContextBinding,
+      Feed.Feed,
       HasSubject.HasSubject,
-      Prompt.Prompt,
-      ResearchGraph,
+      Message.Message,
+      Routine.Routine,
+      Agent.Agent,
+      McpServer.McpServer,
+      Plan.Plan,
       Sequence,
+      Memory.Memory,
+      Text.Text,
     ],
   }),
+  AppPlugin.addSettingsModule({ activate: Settings }),
+  AppPlugin.addSurfaceModule({
+    activate: ReactSurface,
+    firesBeforeActivation: [AppActivationEvents.SetupArtifactDefinition],
+  }),
+  AppPlugin.addTranslationsModule({ translations }),
+  Plugin.addModule({
+    id: 'markdown',
+    activatesOn: MarkdownEvents.SetupExtensions,
+    activate: MarkdownExtension,
+  }),
+  Plugin.addModule({
+    // TODO(wittjosiah): Does not integrate with settings store.
+    //   Should this be a different event?
+    //   Should settings store be renamed to be more generic?
+    activatesOn: AppActivationEvents.SetupSettings,
+    activate: AssistantState,
+  }),
   Plugin.addModule({
     id: 'on-space-created',
     activatesOn: SpaceEvents.SpaceCreated,
@@ -102,16 +188,6 @@ export const AssistantPlugin = Plugin.define(meta).pipe(
         ),
       ),
   }),
-  Plugin.addModule({
-    activatesOn: ClientEvents.SpacesReady,
-    activate: Repair,
-  }),
-  Common.Plugin.addAppGraphModule({ activate: AppGraphBuilder }),
-  Common.Plugin.addOperationResolverModule({ activate: OperationResolver }),
-  Common.Plugin.addSurfaceModule({
-    activate: ReactSurface,
-    activatesBefore: [Common.ActivationEvent.SetupArtifactDefinition],
-  }),
   Plugin.addModule({
     activatesOn: AssistantEvents.SetupAiServiceProviders,
     activate: EdgeModelResolver,
@@ -121,16 +197,42 @@ export const AssistantPlugin = Plugin.define(meta).pipe(
     activate: LocalModelResolver,
   }),
   Plugin.addModule({
-    activatesBefore: [AssistantEvents.SetupAiServiceProviders],
+    firesBeforeActivation: [AssistantEvents.SetupAiServiceProviders],
     // TODO(dmaretskyi): This should activate lazily when the AI chat is used.
-    activatesOn: Common.ActivationEvent.Startup,
+    activatesOn: ActivationEvents.Startup,
     activate: AiService,
   }),
-  Common.Plugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),
   Plugin.addModule({
     // TODO(wittjosiah): Use a different event.
-    activatesOn: Common.ActivationEvent.Startup,
+    activatesOn: ActivationEvents.Startup,
     activate: Toolkit,
   }),
+  Plugin.addModule({
+    activatesOn: ActivationEvent.allOf(
+      ActivationEvents.OperationInvokerReady,
+      AppActivationEvents.AppGraphReady,
+      DeckEvents.StateReady,
+    ),
+    activate: CompanionChatProvisioner,
+  }),
+  Plugin.addModule({
+    activatesOn: ClientEvents.SetupMigration,
+    activate: Migrations,
+  }),
   Plugin.make,
 );
+
+// TODO(dmaretskyi): Extract to a helper module.
+const withComputeRuntime =
+  (spaceId: SpaceId) =>
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, E, Exclude<R, AutomationCapabilities.ComputeServices> | Capability.Service> =>
+    Effect.gen(function* () {
+      // TODO(dmaretskyi): Capability.get has `Error` in the error channel. We should throw those as defects instead.
+      const provider = yield* Capability.get(AutomationCapabilities.ComputeRuntime).pipe(Effect.orDie);
+      const runtime = yield* provider.getRuntime(spaceId).runtimeEffect;
+      return yield* effect.pipe(Effect.provide(runtime));
+    });
+
+export default AssistantPlugin;

package/src/blueprints/assistant/blueprint.test.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { DatabaseBlueprint, DatabaseHandlers } from '@dxos/assistant-toolkit';
+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';
+
+import AssistantBlueprint from './blueprint';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  aiServicePreset: 'edge-remote',
+  operationHandlers: DatabaseHandlers,
+  types: [Organization.Organization, Blueprint.Blueprint, Feed.Feed],
+  blueprints: [AssistantBlueprint.make(), DatabaseBlueprint.make()],
+  tracing: 'pretty',
+});
+
+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* (_) {
+        const agent = yield* AgentService.createSession({
+          blueprints: [AssistantBlueprint.make(), DatabaseBlueprint.make()],
+        });
+        yield* agent.submitPrompt('Create a new organization called "Test Corp".');
+        yield* agent.waitForCompletion();
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 60_000 },
+  );
+});

package/src/blueprints/assistant/blueprint.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { templates } from '@dxos/assistant';
+import { Blueprint } from '@dxos/compute';
+
+import { AssistantOperation } from '#operations';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.assistant';
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Assistant',
+    tools: Blueprint.toolDefinitions({
+      // TODO(wittjosiah): LayoutOperation.Open requires Capability.Service which is only available
+      //   via the compute-runtime layer (plugin-automation). Once Capability.Service is propagated
+      //   through LocalFunctionExecutionService, this will work without the compute-runtime dependency.
+      operations: [LayoutOperation.Open, AssistantOperation.ResolveNavigationTargets],
+    }),
+    instructions: templates.system,
+  });
+
+const blueprint: Blueprint.Definition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/assistant/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as AssistantBlueprint } from './blueprint';

package/src/blueprints/index.ts

@@ -2,11 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Blueprint } from '@dxos/blueprints';
-import { type FunctionDefinition } from '@dxos/functions';
-
-import * as AssistantBlueprint from './assistant-blueprint';
-
-export { AssistantBlueprint };
-export const blueprints: Blueprint.Blueprint[] = AssistantBlueprint.blueprints;
-export const functions: FunctionDefinition[] = AssistantBlueprint.functions;
+export * from './assistant';

package/src/capabilities/{ai-service/ai-service.ts → ai-service.ts}

@@ -6,11 +6,12 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AiModelResolver } from '@dxos/ai';
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    const resolvers = yield* Capability.getAll(Common.Capability.AiModelResolver);
+    const resolvers = yield* Capability.getAll(AppCapabilities.AiModelResolver);
 
     // TODO(dmaretskyi): Extract function to reduce them.
     const combinedLayer = resolvers.reduce(
@@ -21,7 +22,7 @@ export default Capability.makeModule(
     return [
       // TODO(dmaretskyi): Read config from settings.
       Capability.contributes(
-        Common.Capability.AiServiceLayer,
+        AppCapabilities.AiServiceLayer,
         AiModelResolver.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer)),
       ),
     ];

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

@@ -0,0 +1,161 @@
+//
+// 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 { Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine, Operation } 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 { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
+import { linkedSegment } from '@dxos/react-ui-attention';
+
+import { ASSISTANT_COMPANION_VARIANT, meta } from '#meta';
+import { AssistantOperation } from '#operations';
+import { AssistantCapabilities } from '#types';
+
+/** 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 computeRuntime = yield* Capability.get(AutomationCapabilities.ComputeRuntime);
+                  const db = Obj.getDatabase(chat);
+                  invariant(db);
+                  const runtime = yield* computeRuntime.getRuntime(db.spaceId).runtimeEffect;
+                  yield* Operation.invoke(AssistantOperation.UpdateChatName, { chat }).pipe(Effect.provide(runtime));
+                }),
+              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: '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: 'hoist',
+              }),
+            ];
+          }),
+      }),
+
+      GraphBuilder.createExtension({
+        id: 'invocations',
+        match: NodeMatcher.whenAny(
+          NodeMatcher.whenEchoTypeMatches(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: 'fallback',
+            }),
+          ]),
+      }),
+    ]);
+
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/blueprint-definition.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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,
+  LinearBlueprint,
+  PlanningBlueprint,
+  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';
+
+// TODO(dmaretskyi): Force this type for all Capability.makeModule calls.
+const blueprintDefinition: () => Effect.Effect<Capability.Capability<unknown>[]> = Capability.makeModule(() =>
+  Effect.succeed([
+    Capability.contributes(AppCapabilities.BlueprintDefinition, AssistantBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, BrowserBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, DatabaseBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, WebSearchBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, DiscordBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, LinearBlueprint),
+    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, 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, AgentWizardHandlers),
+  ]),
+);
+
+export default blueprintDefinition;