@dxos/plugin-assistant 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

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

@@ -6,25 +6,34 @@ import * as Effect from 'effect/Effect';
 import { pipe } from 'effect/Function';
 import * as Option from 'effect/Option';
 
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { AppCapabilities, AppNode, getActiveSpace, getPersonalSpace, LayoutOperation } from '@dxos/app-toolkit';
-import { Chat } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt } from '@dxos/blueprints';
+import { Capability } from '@dxos/app-framework';
+import {
+  AppCapabilities,
+  AppNode,
+  LayoutOperation,
+  createTypeSectionExtension,
+  createTypeSectionPathResolver,
+  getActiveSpace,
+  getPersonalSpace,
+} from '@dxos/app-toolkit';
+import { AgentPrompt, Chat } from '@dxos/assistant-toolkit';
+import { isSpace } from '@dxos/client/echo';
+import { 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 { DXN, Database, Filter, Obj, Query, Type, type Ref } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
-import { Operation, type OperationInvoker } from '@dxos/operation';
-import { AutomationCapabilities } from '@dxos/plugin-automation/types';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
-import { SpaceOperation } from '@dxos/plugin-space/operations';
-import { Query } from '@dxos/react-client/echo';
+import { SpaceOperation } from '@dxos/plugin-space';
 import { linkedSegment } from '@dxos/react-ui-attention';
 
-import { ASSISTANT_COMPANION_VARIANT, ASSISTANT_DIALOG, meta } from '#meta';
-import { AssistantOperation } from '#operations';
-import { AssistantCapabilities } from '#types';
+import { ASSISTANT_COMPANION_VARIANT, meta } from '#meta';
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+import { getChatsPath } from '../paths';
+
+/** 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(
@@ -47,11 +56,9 @@ export default Capability.makeModule(
               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));
+                  yield* Operation.invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId: db.spaceId });
                 }),
               properties: {
                 label: ['chat-update-name.label', { ns: meta.id }],
@@ -69,58 +76,40 @@ export default Capability.makeModule(
         actions: () =>
           Effect.succeed([
             Node.makeAction({
-              id: `${LayoutOperation.UpdateDialog.meta.key}.assistant.open`,
+              id: 'importComputeOperations',
               data: Effect.fnUntraced(function* () {
                 const capabilities = yield* Capability.Service;
                 const client = yield* Capability.get(ClientCapabilities.Client);
-                const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
                 const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
                 if (!space) {
                   return;
                 }
-                const chat = yield* Effect.tryPromise(() => getOrCreateChat(operationInvoker.invokePromise, space.db));
-                if (!chat) {
-                  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* Operation.invoke(LayoutOperation.UpdateDialog, {
-                  subject: ASSISTANT_DIALOG,
-                  state: true,
-                  blockAlign: 'end',
-                  props: { chat },
-                });
+                yield* Database.flush();
               }),
               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',
-                },
+                label: ['import-compute-operations.label', { ns: meta.id }],
+                icon: 'ph--download-simple--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();
-              }),
+              id: AssistantOperation.ToggleTracePanelDebug.meta.key,
+              data: () => Operation.invoke(AssistantOperation.ToggleTracePanelDebug, {}),
               properties: {
-                label: ['reset-blueprints.label', { ns: meta.id }],
-                icon: 'ph--arrow-clockwise--regular',
+                label: ['toggle-trace-panel-debug.label', { ns: meta.id }],
+                icon: 'ph--brackets-curly--regular',
               },
             }),
           ]),
@@ -128,22 +117,22 @@ export default Capability.makeModule(
 
       // Don't show assistant companion when a chat is already the primary object.
       GraphBuilder.createExtension({
-        id: 'companion-chat',
+        id: 'companionChat',
         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();
+            const objectUri = Obj.getURI(object);
 
             // 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.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.map((ref) => get(Obj.atom(ref as Ref.Ref<Obj.Unknown>))),
               Option.filter(Obj.isObject),
-              Option.orElse(() => pipe(Option.fromNullable(cache[objectDxn]), Option.filter(Obj.isObject))),
+              Option.orElse(() => pipe(Option.fromNullable(cache[objectUri]), Option.filter(Obj.isObject))),
               Option.getOrNull,
             );
 
@@ -153,7 +142,7 @@ export default Capability.makeModule(
                 label: ['assistant-chat.label', { ns: meta.id }],
                 icon: 'ph--sparkle--regular',
                 data: chat,
-                position: 'hoist',
+                position: 'first',
               }),
             ];
           }),
@@ -162,8 +151,8 @@ export default Capability.makeModule(
       GraphBuilder.createExtension({
         id: 'invocations',
         match: NodeMatcher.whenAny(
-          NodeMatcher.whenEchoTypeMatches(Sequence),
-          NodeMatcher.whenEchoTypeMatches(Prompt.Prompt),
+          NodeMatcher.whenEchoTypeMatches(Sequence.Sequence),
+          NodeMatcher.whenEchoTypeMatches(Routine.Routine),
         ),
         connector: () =>
           Effect.succeed([
@@ -186,32 +175,63 @@ export default Capability.makeModule(
               label: ['trace.label', { ns: meta.id }],
               icon: 'ph--line-segments--regular',
               data: 'trace' as const,
-              position: 'fallback',
+              position: 'last',
+            }),
+          ]),
+      }),
+
+      // Section node: standalone Chat.Chat objects per space (companions are excluded).
+      createTypeSectionExtension(Chat.Chat, {
+        // Exclude chats that are the source of a CompanionTo relation; those belong to
+        // their primary object's companion panel and should not appear in the top-level list.
+        query: Query.without(
+          Query.select(Filter.type(Chat.Chat)),
+          Query.select(Filter.type(Chat.Chat)).sourceOf(Chat.CompanionTo).source(),
+        ),
+      }),
+
+      // Create-chat action on the Chats section header.
+      GraphBuilder.createExtension({
+        id: 'chatsSectionActions',
+        match: (node) => {
+          const space = isSpace(node.properties.space) ? node.properties.space : undefined;
+          return node.type === Type.getTypename(Chat.Chat) && space ? Option.some(space) : Option.none();
+        },
+        actions: (space) =>
+          Effect.succeed([
+            Node.makeAction({
+              id: 'create-chat',
+              data: () =>
+                Effect.gen(function* () {
+                  const { object: chat } = yield* Operation.invoke(
+                    AssistantOperation.CreateChat,
+                    { db: space.db },
+                    { spaceId: space.db.spaceId },
+                  );
+                  const { subject } = yield* Operation.invoke(
+                    SpaceOperation.AddObject,
+                    { object: chat, target: space.db, hidden: true, targetNodeId: getChatsPath(space.db.spaceId) },
+                    { spaceId: space.db.spaceId },
+                  );
+                  yield* Operation.invoke(
+                    LayoutOperation.Open,
+                    { subject: [...subject] },
+                    { spaceId: space.db.spaceId },
+                  );
+                }),
+              properties: {
+                label: ['create-chat.label', { ns: meta.id }],
+                icon: 'ph--plus--regular',
+                disposition: 'list-item-primary',
+              },
             }),
           ]),
       }),
     ]);
 
-    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+    return [
+      Capability.contributes(AppCapabilities.AppGraphBuilder, extensions),
+      Capability.contributes(AppCapabilities.NavigationPathResolver, createTypeSectionPathResolver(Chat.Chat)),
+    ];
   }),
 );
-
-// TODO(burdon): Factor out.
-const getOrCreateChat = async (
-  invokePromise: OperationInvoker.OperationInvoker['invokePromise'],
-  db: Database.Database,
-): Promise<Chat.Chat | undefined> => {
-  // TODO(wittjosiah): This should be possible with a single query.
-  const allChats = await db.query(Query.type(Chat.Chat)).run();
-  const relatedChats = await db.query(Query.type(Chat.Chat).sourceOf(Chat.CompanionTo).source()).run();
-
-  const chats = allChats.filter((chat) => !relatedChats.includes(chat));
-  if (chats.length > 0) {
-    return chats.at(-1);
-  }
-
-  const { data } = await invokePromise(AssistantOperation.CreateChat, { db });
-  invariant(Obj.instanceOf(Chat.Chat, data?.object));
-  await invokePromise(SpaceOperation.AddObject, { target: db, object: data.object });
-  return data.object;
-};

package/src/capabilities/automation-templates.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
+
+import { automationTemplates } from '../templates';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return automationTemplates.map((template) => Capability.contributes(AutomationCapabilities.Template, template));
+  }),
+);

package/src/capabilities/blueprint-definition.ts

@@ -18,24 +18,26 @@ import {
   DatabaseBlueprint,
   DatabaseHandlers,
   DiscordBlueprint,
-  EntityExtractionHandlers,
   LinearBlueprint,
   PlanningBlueprint,
-  ResearchBlueprint,
   WebSearchBlueprint,
+  WebSearchHandlers,
   MemoryBlueprint,
   AutomationBlueprint,
+  DelegationBlueprint,
+  DelegationHandlers,
+  makeDelegationStrategy,
 } from '@dxos/assistant-toolkit';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
 
 import { AssistantBlueprint } from '#blueprints';
 
-// TODO(dmaretskyi): Force this type for all Capability.makeModule calls.
-const blueprintDefinition: () => Effect.Effect<Capability.Capability<unknown>[]> = Capability.makeModule(() =>
+// NOTE: Explicit annotation required: d.ts emit cannot portably name the inferred @dxos/compute types (TS2883).
+const blueprintDefinition: () => Effect.Effect<Capability.Capability<unknown>[]> = () =>
   Effect.succeed([
     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),
@@ -45,14 +47,19 @@ const blueprintDefinition: () => Effect.Effect<Capability.Capability<unknown>[]>
     Capability.contributes(AppCapabilities.BlueprintDefinition, AutomationBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, BlueprintManagerBlueprint),
     Capability.contributes(AppCapabilities.BlueprintDefinition, AgentWizardBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, DelegationBlueprint),
 
     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, WebSearchHandlers),
     Capability.contributes(Capabilities.OperationHandler, AgentWizardHandlers),
-  ]),
-);
+    Capability.contributes(Capabilities.OperationHandler, DelegationHandlers),
+
+    // Run the conversational agent as a supervisor: delegate in-progress plan tasks to sub-agents
+    // and fold their results back into the conversation (consumed by the AgentService LayerSpec).
+    Capability.contributes(AutomationCapabilities.AgentDelegationStrategy, makeDelegationStrategy()),
+  ]);
 
 export default blueprintDefinition;

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

@@ -12,13 +12,12 @@ 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/types';
+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 { AssistantOperation } from '#operations';
-import { AssistantCapabilities } from '#types';
+import { AssistantCapabilities, AssistantOperation } from '#types';
 
 /**
  * Non-React capability that watches deck companion state and provisions transient chats
@@ -65,14 +64,15 @@ export default Capability.makeModule(
       }
 
       const object = node.data;
-      const companionDxn = Obj.getDXN(object).toString();
+      const companionUri = Obj.getURI(object);
       const cache = registry.get(cacheAtom);
-      if (cache[companionDxn]) {
+      if (cache[companionUri]) {
         return true;
       }
 
       const db = Obj.getDatabase(object);
       if (!db) {
+        log.warn('No db for object', { plankId, companionUri });
         return false;
       }
 

package/src/capabilities/create-object.ts

@@ -0,0 +1,100 @@
+//
+// 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, Type } from '@dxos/echo';
+import { SpaceCapabilities, SpaceOperation } from '@dxos/plugin-space';
+
+import { AssistantOperation } from '#types';
+
+import { getChatsPath } from '../paths';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Chat.Chat),
+        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 ?? getChatsPath(options.db.spaceId),
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Blueprint.Blueprint),
+        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: Type.getTypename(Routine.Routine),
+        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: Type.getTypename(Sequence.Sequence),
+        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: Type.getTypename(Agent.Agent),
+        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).pipe(
+                Layer.provide(Capability.asLayer(Capabilities.ServiceResolver, ServiceResolver.ServiceResolver)),
+              ),
+            ),
+          ),
+      }),
+    ];
+  }),
+);

package/src/capabilities/edge-model-resolver.ts

@@ -3,31 +3,68 @@
 //
 
 import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
-import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AnthropicResolver } from '@dxos/ai/resolvers';
 import { Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
+import { createEdgeIdentity } from '@dxos/client/edge';
+import { Header } from '@dxos/compute';
+import { EdgeAiHttpClient, EdgeHttpClient } from '@dxos/edge-client';
+import { invariant } from '@dxos/invariant';
+import { ClientCapabilities } from '@dxos/plugin-client';
 
-export type EdgeModelResolverCapabilities = [Capability.Capability<typeof AppCapabilities.AiModelResolver>];
+import { ANTHROPIC_SOURCE } from '../constants';
 
-const edgeModelResolver = Capability.makeModule<[], EdgeModelResolverCapabilities>(() =>
-  Effect.succeed([
-    Capability.contributes(
+// Named alias so the module's inferred type stays portable (avoids TS2883 leaking the internal
+// `@dxos/ai/AiModelResolver` Layer type into the emitted declarations).
+export type EdgeModelResolverCapabilities = Capability.Capability<typeof AppCapabilities.AiModelResolver>[];
+
+const edgeModelResolver = Capability.makeModule<[], EdgeModelResolverCapabilities>(
+  Effect.fnUntraced(function* () {
+    const manager = yield* Capability.Service;
+
+    // The authenticated EDGE client is resolved lazily on the first AI request. AI providers are
+    // set up before the Client capability and user identity exist (the startup cascade activates
+    // this module before `ClientReady`), so requiring the Client here would throw — or deadlock
+    // if we blocked on it. `EdgeAiHttpClient` invokes this thunk per request, by which point the
+    // Client is available.
+    let edgeClient: EdgeHttpClient | undefined;
+    let identitySubscription: { unsubscribe: () => void } | undefined;
+    const getEdgeClient = (): EdgeHttpClient => {
+      if (!edgeClient) {
+        const [client] = manager.getAll(ClientCapabilities.Client);
+        invariant(client, 'Client capability is required for edge AI requests.');
+        const edgeUrl = client.config.values.runtime?.services?.edge?.url;
+        invariant(edgeUrl, 'EDGE services are not configured.');
+        const created = new EdgeHttpClient(edgeUrl);
+        const updateIdentity = () => {
+          if (client.halo.identity.get()) {
+            created.setIdentity(createEdgeIdentity(client));
+          }
+        };
+        updateIdentity();
+        identitySubscription = client.halo.identity.subscribe(updateIdentity);
+        edgeClient = created;
+      }
+      return edgeClient;
+    };
+
+    // `apiUrl` is a sentinel; `EdgeAiHttpClient` rewrites the request onto the EDGE
+    // `/ai/generate/anthropic` route. `Header.byokLayer` wraps that client to inject `X-BYOK`.
+    const httpClient = Header.byokLayer(ANTHROPIC_SOURCE).pipe(Layer.provide(EdgeAiHttpClient.layer(getEdgeClient)));
+    const anthropicClient = AnthropicClient.layer({ apiUrl: 'http://edge.internal' }).pipe(Layer.provide(httpClient));
+    const anthropicResolverLayer = AnthropicResolver.make().pipe(Layer.provide(anthropicClient));
+
+    const contribution: Capability.Capability<typeof AppCapabilities.AiModelResolver> = Capability.contributes(
       AppCapabilities.AiModelResolver,
-      AnthropicResolver.make().pipe(
-        Layer.provide(
-          AnthropicClient.layer({
-            // TODO(dmaretskyi): Read endpoint from config/settings.
-            apiUrl: 'https://ai-service.dxos.workers.dev/provider/anthropic',
-          }),
-        ),
-        Layer.provide(FetchHttpClient.layer),
-      ),
-    ),
-  ]),
+      anthropicResolverLayer,
+      () => Effect.sync(() => identitySubscription?.unsubscribe()),
+    );
+
+    return [contribution];
+  }),
 );
 
 export default edgeModelResolver;

package/src/capabilities/index.ts

@@ -3,18 +3,38 @@
 //
 
 import { Capability } from '@dxos/app-framework';
-import { OperationHandlerSet } from '@dxos/operation';
+import type { OperationHandlerSet } from '@dxos/compute';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
 
-export const AiService = Capability.lazy('AiService', () => import('./ai-service'));
+import type { AssistantPluginOptions } from '#types';
+
+export const AgentHydrator = Capability.lazy('AgentHydrator', () => import('./agent-hydrator'));
+export const AgentRuntime = Capability.lazy<void, Capability.Any[]>('AgentRuntime', () => import('./agent-service'));
+export const AiContext = Capability.lazy<void, Capability.Any[]>('AiContext', () => import('./ai-context'));
+export const AiService = Capability.lazy<AssistantPluginOptions | void, Capability.Any[]>(
+  'AiService',
+  () => import('./ai-service'),
+);
+export const IntegrationProvider = Capability.lazy(
+  'AnthropicIntegrationProvider',
+  () => import('./integration-provider'),
+);
 export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+// Explicit annotation: the contributed capability type references `Template` from @dxos/plugin-automation,
+// so the inferred lazy type needs annotating to stay portable (TS2883).
+export const AutomationTemplates: Capability.LazyCapability<
+  void,
+  Capability.Capability<typeof AutomationCapabilities.Template>[]
+> = Capability.lazy('AutomationTemplates', () => import('./automation-templates'));
 export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
 export const CompanionChatProvisioner = Capability.lazy(
   'CompanionChatProvisioner',
   () => import('./companion-chat-provisioner'),
 );
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
 export const EdgeModelResolver = Capability.lazy('EdgeModelResolver', () => import('./edge-model-resolver'));
 export const LocalModelResolver = Capability.lazy('LocalModelResolver', () => import('./local-model-resolver'));
-export const MarkdownExtension = Capability.lazy('MarkdownExtension', () => import('./markdown'));
+export const MarkdownExtension = Capability.lazy('MarkdownExtension', () => import('./markdown-extension'));
 export const Migrations = Capability.lazy('AssistantMigrations', () => import('./migrations'));
 export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
   'OperationHandler',