@dxos/plugin-assistant 0.8.4-main.ead640a → 0.8.4-main.effb148878

package/src/AssistantPlugin.workerd.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { AiContext } from '@dxos/assistant';
+import { Agent, Chat, McpServer, Memory, Plan } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { Feed } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { HasSubject, Message } from '@dxos/types';
+
+import { OperationHandler } from '#capabilities';
+import { meta } from '#meta';
+
+export const AssistantPlugin = Plugin.define(meta).pipe(
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      Chat.Chat,
+      Chat.CompanionTo,
+      Blueprint.Blueprint,
+      AiContext.Binding,
+      Feed.Feed,
+      HasSubject.HasSubject,
+      Message.Message,
+      Routine.Routine,
+      Agent.Agent,
+      McpServer.McpServer,
+      Plan.Plan,
+      Sequence.Sequence,
+      Memory.Memory,
+      Text.Text,
+    ],
+  }),
+  Plugin.make,
+);
+
+export default AssistantPlugin;

package/src/blueprints/assistant/blueprint.node.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 '#types';
+
+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/{components/Toolbar → blueprints}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './Toolbar';
+export * from './assistant';

package/src/capabilities/ai-context.ts

@@ -0,0 +1,85 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AiContext } from '@dxos/assistant';
+import { LayerSpec, ServiceNotAvailableError } from '@dxos/compute';
+import { Database, EchoURI, Feed } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+
+//
+// Capability Module
+//
+// Contributes a process-affinity `LayerSpec` that materialises
+// {@link AiContext.Service} from the resolution context's `conversation` DXN.
+//
+// Previously, `AiContext.Service` was provided only inline by the assistant
+// plugin processor and by `AiSession.createRequest`. That works while the
+// formatting code runs inside the calling fiber, but breaks the moment any
+// nested call crosses a process boundary via `Operation.invoke` — the spawned
+// process gets its own `ServiceResolver`/`LayerStack` and there is no
+// production provider for `AiContext.Service` to back it.
+//
+// The dispatcher path (trigger → AgentWorker → AiSession.createRequest →
+// formatSystemPrompt → Template.processTemplate → Operation.invoke(GetContext))
+// hits exactly this gap: `GetContext` declares `services: [AiContext.Service,
+// Database.Service]`, the child spawn inherits `space` + `conversation` from
+// the parent's environment (see TriggerDispatcher + Operation.invoke), but
+// then `LayerStack` has nothing to satisfy `AiContext.Service` with.
+//
+// This spec mirrors the test-layer factory in
+// `@dxos/functions-runtime/testing` so the production resolver behaves the
+// same way: load the conversation feed via `Database.Service`, hand it to an
+// `AiContext.Binder`, and scope the binder to the process slice's lifetime.
+//
+
+/**
+ * Process-affinity LayerSpec for {@link AiContext.Service}.
+ *
+ * The factory runs once per process slice (keyed on space + conversation +
+ * process id). If `context.conversation` is absent the slice fails with a
+ * `ServiceNotAvailable` defect — there is no useful binder to build without
+ * a conversation feed, and a precise error at slice init beats a silent
+ * binder that throws on first use.
+ */
+const AiContextSpec = LayerSpec.make(
+  {
+    affinity: 'process',
+    requires: [Database.Service, Feed.FeedService],
+    provides: [AiContext.Service],
+  },
+  (context) =>
+    Layer.scoped(
+      AiContext.Service,
+      Effect.gen(function* () {
+        // The spec is registered unconditionally so the LayerStack knows how
+        // to satisfy `AiContext.Service` in principle. Surface a precise
+        // failure when the conversation context is missing — this happens
+        // when an operation that requires `AiContext.Service` is invoked
+        // without going through `Operation.withInvocationOptions({
+        // conversation })` (or equivalent spawn `environment`). Raised as a
+        // defect because the spec's factory must produce
+        // `Layer<..., never, ...>`; the trigger dispatcher's `causeToError`
+        // path still surfaces the original message in logs.
+        if (!context.conversation) {
+          return yield* Effect.die(
+            new ServiceNotAvailableError(AiContext.Service.key, {
+              message: `Service not available: ${AiContext.Service.key} — process spawn is missing 'conversation' in environment (set via Operation.withInvocationOptions or ProcessManager.spawn environment)`,
+            }),
+          );
+        }
+        const feed = yield* Database.resolve(EchoURI.parse(context.conversation), Feed.Feed).pipe(Effect.orDie);
+        const runtime = yield* Effect.runtime<Feed.FeedService>();
+        const binder = yield* acquireReleaseResource(() => new AiContext.Binder({ feed, runtime }));
+        return { binder };
+      }),
+    ),
+);
+
+export default Capability.makeModule(() =>
+  Effect.succeed([Capability.contributes(Capabilities.LayerSpec, AiContextSpec)]),
+);

package/src/capabilities/ai-service.ts

@@ -5,23 +5,40 @@
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
+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 (context: PluginContext) => {
-  const resolvers = context.getCapabilities(Capabilities.AiModelResolver);
+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)),
-    AiServiceRouter.AiModelResolver.fromModelMap(Effect.succeed({})), // Empty resolver as fallback.
-  );
+    // 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.
+    );
 
-  return [
-    // TODO(dmaretskyi): Read config from settings.
-    contributes(
-      Capabilities.AiServiceLayer,
-      AiServiceRouter.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer)),
-    ),
-  ];
-};
+    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

@@ -2,193 +2,196 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import * as Function from 'effect/Function';
+import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
 import * as Option from 'effect/Option';
 
-import {
-  Capabilities,
-  LayoutAction,
-  type PluginContext,
-  type PromiseIntentDispatcher,
-  contributes,
-  createIntent,
-} from '@dxos/app-framework';
+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 { Obj } from '@dxos/echo';
+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 { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { ROOT_ID, createExtension, rxFromSignal } from '@dxos/plugin-graph';
-import { getActiveSpace } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Query, type Space, fullyQualifiedId } from '@dxos/react-client/echo';
+import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
+import { linkedSegment } from '@dxos/react-ui-attention';
 
-import { ASSISTANT_DIALOG, meta } from '../meta';
-import { Assistant, AssistantAction } from '../types';
+import { ASSISTANT_COMPANION_VARIANT, meta } from '#meta';
+import { AssistantCapabilities, AssistantOperation } from '#types';
 
-import { AssistantCapabilities } from './capabilities';
+/** Operation definitions to seed as `PersistentOperation` records for automation / triggers. */
+const computeOperationsToImport = [AgentPrompt] as const;
 
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${meta.id}/root`,
-      actions: (node) =>
-        Rx.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => {
-              return Obj.instanceOf(Assistant.Chat, node.data) ? Option.some(node.data) : Option.none();
-            }),
-            Option.map((object) => {
-              const id = fullyQualifiedId(object);
-              return [
-                {
-                  id: `${AssistantAction.UpdateChatName._tag}/${id}`,
-                  data: async () => {
-                    const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-                    await dispatch(createIntent(AssistantAction.UpdateChatName, { chat: object }));
-                  },
-                  properties: {
-                    label: ['chat update name label', { ns: meta.id }],
-                    icon: 'ph--magic-wand--regular',
-                    disposition: 'list-item',
-                  },
-                },
-              ];
+/** 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',
+              },
             }),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
+          ]);
+        },
+      }),
 
-    createExtension({
-      id: `${meta.id}/assistant`,
-      actions: (node) =>
-        Rx.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
-            Option.map(() => [
-              {
-                id: `${LayoutAction.UpdateDialog._tag}/assistant/open`,
-                data: async () => {
-                  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-                  const client = context.getCapability(ClientCapabilities.Client);
-                  const space = getActiveSpace(context) ?? client.spaces.default;
-                  const chat = await getOrCreateChat(dispatch, space);
-                  if (!chat) {
-                    return;
+      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;
                   }
-
-                  await dispatch(
-                    createIntent(LayoutAction.UpdateDialog, {
-                      part: 'dialog',
-                      subject: ASSISTANT_DIALOG,
-                      options: {
-                        state: true,
-                        blockAlign: 'end',
-                        props: {
-                          chat,
-                        },
-                      },
-                    }),
+                  const existing = yield* Effect.promise(
+                    (): Promise<Operation.PersistentOperation[]> =>
+                      space.db.query(Filter.and(Filter.type(Operation.PersistentOperation), Filter.key(key))).run(),
                   );
-                },
-                properties: {
-                  label: ['open assistant label', { ns: meta.id }],
-                  icon: 'ph--sparkle--regular',
-                  disposition: 'pin-end',
-                  position: 'hoist',
-                  keyBinding: {
-                    macos: 'shift+meta+k',
-                    windows: 'shift+ctrl+k',
-                  },
-                },
+                  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',
               },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
+            }),
+            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',
+              },
+            }),
+          ]),
+      }),
 
-    createExtension({
-      id: `${meta.id}/companion-chat`,
-      connector: (node) => {
-        return Rx.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (Obj.isObject(node.data) ? Option.some(node.data) : Option.none())),
-            Option.map((object) => {
-              const currentChat = get(
-                rxFromSignal(
-                  () => context.getCapability(AssistantCapabilities.State).currentChat[fullyQualifiedId(object)],
-                ),
-              );
+      // 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 objectUri = Obj.getURI(object);
 
-              return [
-                {
-                  id: [fullyQualifiedId(object), 'assistant-chat'].join(ATTENDABLE_PATH_SEPARATOR),
-                  type: PLANK_COMPANION_TYPE,
-                  data: currentChat ?? 'assistant-chat',
-                  properties: {
-                    label: ['assistant chat label', { ns: meta.id }],
-                    icon: 'ph--sparkle--regular',
-                    position: 'hoist',
-                    disposition: 'hidden',
-                  },
-                },
-              ];
-            }),
-            Option.getOrElse(() => []),
-          ),
-        );
-      },
-    }),
+            // Resolve chat from persisted state or transient cache.
+            const chat = pipe(
+              Option.fromNullable(state.currentChat[objectUri]),
+              Option.flatMap((dxnStr) => Option.fromNullable(DXN.tryMake(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[objectUri]), Option.filter(Obj.isObject))),
+              Option.getOrNull,
+            );
 
-    createExtension({
-      id: `${meta.id}/sequence-logs`,
-      connector: (node) =>
-        Rx.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (Obj.instanceOf(Sequence, node.data) ? Option.some(node) : Option.none())),
-            Option.map((node) => [
-              {
-                id: [node.id, 'logs'].join(ATTENDABLE_PATH_SEPARATOR),
-                type: PLANK_COMPANION_TYPE,
-                data: 'logs',
-                properties: {
-                  label: ['sequence logs label', { ns: meta.id }],
-                  icon: 'ph--clock-countdown--regular',
-                  disposition: 'hidden',
-                },
-              },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-  ]);
+            return [
+              AppNode.makeCompanion({
+                id: linkedSegment(ASSISTANT_COMPANION_VARIANT),
+                label: ['assistant-chat.label', { ns: meta.id }],
+                icon: 'ph--sparkle--regular',
+                data: chat,
+                position: 'first',
+              }),
+            ];
+          }),
+      }),
 
-// TODO(burdon): Factor out.
-const getOrCreateChat = async (
-  dispatch: PromiseIntentDispatcher,
-  space: Space,
-): Promise<Assistant.Chat | undefined> => {
-  // TODO(wittjosiah): This should be possible with a single query.
-  const { objects: allChats } = await space.db.query(Query.type(Assistant.Chat)).run();
-  const { objects: relatedChats } = await space.db
-    .query(Query.type(Assistant.Chat).sourceOf(Assistant.CompanionTo).source())
-    .run();
+      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',
+            }),
+          ]),
+      }),
 
-  const chats = allChats.filter((chat) => !relatedChats.includes(chat));
-  if (chats.length > 0) {
-    return chats.at(-1);
-  }
+      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',
+            }),
+          ]),
+      }),
+    ]);
 
-  const { data } = await dispatch(createIntent(AssistantAction.CreateChat, { space }));
-  invariant(Obj.instanceOf(Assistant.Chat, data?.object));
-  await dispatch(createIntent(SpaceAction.AddObject, { target: space, object: data.object }));
-  return data.object;
-};
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);