@dxos/plugin-assistant 0.8.4-main.21d9917 → 0.8.4-main.2244d791bb

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

@@ -4,10 +4,12 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { Prompt } from '@dxos/blueprints';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Blueprint, Prompt } from '@dxos/blueprints';
 import { Sequence } from '@dxos/conductor';
-import { DXN, type Database, Obj, type Ref } from '@dxos/echo';
+import { DXN, Database, Obj, type Ref } from '@dxos/echo';
 import { AtomObj } from '@dxos/echo-atom';
 import { invariant } from '@dxos/invariant';
 import { Operation, type OperationInvoker } from '@dxos/operation';
@@ -19,7 +21,7 @@ import { SpaceOperation } from '@dxos/plugin-space/types';
 import { Query } from '@dxos/react-client/echo';
 
 import { ASSISTANT_DIALOG, meta } from '../../meta';
-import { Assistant, AssistantCapabilities, AssistantOperation } from '../../types';
+import { AssistantCapabilities, AssistantOperation } from '../../types';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
@@ -28,7 +30,7 @@ export default Capability.makeModule(
     const extensions = yield* Effect.all([
       GraphBuilder.createTypeExtension({
         id: `${meta.id}/root`,
-        type: Assistant.Chat,
+        type: Chat.Chat,
         actions: (chat) => {
           const id = Obj.getDXN(chat).toString();
           return Effect.succeed([
@@ -51,18 +53,18 @@ export default Capability.makeModule(
         actions: () =>
           Effect.succeed([
             {
-              id: `${Common.LayoutOperation.UpdateDialog.meta.key}/assistant/open`,
+              id: `${LayoutOperation.UpdateDialog.meta.key}/assistant/open`,
               data: Effect.fnUntraced(function* () {
                 const capabilities = yield* Capability.Service;
                 const client = yield* Capability.get(ClientCapabilities.Client);
-                const operationInvoker = yield* Capability.get(Common.Capability.OperationInvoker);
+                const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
                 const space = getActiveSpace(capabilities) ?? client.spaces.default;
                 const chat = yield* Effect.tryPromise(() => getOrCreateChat(operationInvoker.invokePromise, space.db));
                 if (!chat) {
                   return;
                 }
 
-                yield* Operation.invoke(Common.LayoutOperation.UpdateDialog, {
+                yield* Operation.invoke(LayoutOperation.UpdateDialog, {
                   subject: ASSISTANT_DIALOG,
                   state: true,
                   blockAlign: 'end',
@@ -82,6 +84,25 @@ export default Capability.makeModule(
                 },
               },
             },
+            {
+              id: `${meta.id}/reset-blueprints`,
+              data: Effect.fnUntraced(function* () {
+                const capabilities = yield* Capability.Service;
+                const client = yield* Capability.get(ClientCapabilities.Client);
+                const space = getActiveSpace(capabilities) ?? client.spaces.default;
+                const blueprints = yield* Effect.tryPromise(() =>
+                  space.db.query(Query.type(Blueprint.Blueprint)).run(),
+                );
+                for (const blueprint of blueprints) {
+                  space.db.remove(blueprint);
+                }
+                yield* Database.flush({ indexes: true });
+              }),
+              properties: {
+                label: ['reset blueprints label', { ns: meta.id }],
+                icon: 'ph--arrow-clockwise--regular',
+              },
+            },
           ]),
       }),
 
@@ -113,15 +134,14 @@ export default Capability.makeModule(
             const currentChatDxn = DXN.tryParse(currentChatState);
             const currentChatRef = currentChatDxn ? db?.makeRef(currentChatDxn) : undefined;
             const currentChat = currentChatRef ? get(AtomObj.make(currentChatRef as Ref.Ref<Obj.Unknown>)) : undefined;
-            if (!Obj.isObject(currentChat)) {
-              return [];
-            }
 
+            // Return the resolved chat object, or fall back to 'assistant-chat' string if it can't be resolved.
+            // This ensures the companion remains visible even during transient states.
             return [
               {
                 id: [Obj.getDXN(object).toString(), 'assistant-chat'].join(ATTENDABLE_PATH_SEPARATOR),
                 type: PLANK_COMPANION_TYPE,
-                data: currentChat,
+                data: Obj.isObject(currentChat) ? currentChat : 'assistant-chat',
                 properties: {
                   label: ['assistant chat label', { ns: meta.id }],
                   icon: 'ph--sparkle--regular',
@@ -155,7 +175,7 @@ export default Capability.makeModule(
       }),
     ]);
 
-    return Capability.contributes(Common.Capability.AppGraphBuilder, extensions);
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
   }),
 );
 
@@ -163,10 +183,10 @@ export default Capability.makeModule(
 const getOrCreateChat = async (
   invokePromise: OperationInvoker.OperationInvoker['invokePromise'],
   db: Database.Database,
-): Promise<Assistant.Chat | undefined> => {
+): Promise<Chat.Chat | undefined> => {
   // TODO(wittjosiah): This should be possible with a single query.
-  const allChats = await db.query(Query.type(Assistant.Chat)).run();
-  const relatedChats = await db.query(Query.type(Assistant.Chat).sourceOf(Assistant.CompanionTo).source()).run();
+  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) {
@@ -174,7 +194,7 @@ const getOrCreateChat = async (
   }
 
   const { data } = await invokePromise(AssistantOperation.CreateChat, { db });
-  invariant(Obj.instanceOf(Assistant.Chat, data?.object));
+  invariant(Obj.instanceOf(Chat.Chat, data?.object));
   await invokePromise(SpaceOperation.AddObject, { target: db, object: data.object });
   return data.object;
 };

package/src/capabilities/blueprint-definition/blueprint-definition.ts

@@ -3,58 +3,44 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Record from 'effect/Record';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import {
-  Agent,
-  Discord,
+  AgentFunctions,
   DiscordBlueprint,
-  EntityExtraction,
-  Linear,
+  EntityExtractionFunctions,
+  InitiativeBlueprint,
   LinearBlueprint,
-  Research,
+  PlanningBlueprint,
   ResearchBlueprint,
   WebSearchBlueprint,
 } from '@dxos/assistant-toolkit';
-import { type Blueprint } from '@dxos/blueprints';
 
 import { AssistantBlueprint } from '../../blueprints';
 
-export const createBlueprint: () => Blueprint.Blueprint = AssistantBlueprint.make;
-export { AssistantBlueprint };
-
-export type BlueprintCapabilities = [
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-  Capability.Capability<typeof Common.Capability.Functions>,
-  Capability.Capability<typeof Common.Capability.BlueprintDefinition>,
-];
-
-export default Capability.makeModule<[], BlueprintCapabilities>(() =>
+const blueprintDefinition = Capability.makeModule<
+  [],
+  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]
+>(() =>
   Effect.succeed([
-    Capability.contributes(Common.Capability.Functions, AssistantBlueprint.functions$),
-    Capability.contributes(Common.Capability.BlueprintDefinition, AssistantBlueprint.blueprint),
-
-    // TODO(burdon): Factor out.
-    Capability.contributes(Common.Capability.Functions, [Research.create, Research.research]),
-    Capability.contributes(Common.Capability.BlueprintDefinition, ResearchBlueprint),
-
-    // TODO(burdon): Factor out.
-    Capability.contributes(Common.Capability.Functions, [Agent.prompt, EntityExtraction.extract]),
-    Capability.contributes(Common.Capability.BlueprintDefinition, WebSearchBlueprint),
-
-    // TODO(burdon): Factor out.
-    Capability.contributes(Common.Capability.Functions, [Discord.fetch]),
-    Capability.contributes(Common.Capability.BlueprintDefinition, DiscordBlueprint),
-
-    // TODO(burdon): Factor out.
-    Capability.contributes(Common.Capability.Functions, [Linear.sync]),
-    Capability.contributes(Common.Capability.BlueprintDefinition, LinearBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, {
+      ...AssistantBlueprint,
+      functions: [
+        // TODO(burdon): Co-locate all of these functions?
+        ...AssistantBlueprint.functions,
+        ...Record.values(AgentFunctions),
+        ...Record.values(EntityExtractionFunctions),
+      ],
+    }),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, ResearchBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, WebSearchBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, DiscordBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, LinearBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, InitiativeBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, PlanningBlueprint),
   ]),
 );
+
+export default blueprintDefinition;

package/src/capabilities/blueprint-definition/index.ts

@@ -5,4 +5,3 @@
 import { Capability } from '@dxos/app-framework';
 
 export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
-export { AssistantBlueprint } from './blueprint-definition';

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

@@ -8,14 +8,15 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AnthropicResolver } from '@dxos/ai/resolvers';
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
-export type EdgeModelResolverCapabilities = [Capability.Capability<typeof Common.Capability.AiModelResolver>];
+export type EdgeModelResolverCapabilities = [Capability.Capability<typeof AppCapabilities.AiModelResolver>];
 
 const edgeModelResolver = Capability.makeModule<[], EdgeModelResolverCapabilities>(() =>
   Effect.succeed([
     Capability.contributes(
-      Common.Capability.AiModelResolver,
+      AppCapabilities.AiModelResolver,
       AnthropicResolver.make().pipe(
         Layer.provide(
           AnthropicClient.layer({

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

@@ -8,9 +8,10 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { LMStudioResolver } from '@dxos/ai/resolvers';
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
-export type LocalModelResolverCapabilities = [Capability.Capability<typeof Common.Capability.AiModelResolver>];
+export type LocalModelResolverCapabilities = [Capability.Capability<typeof AppCapabilities.AiModelResolver>];
 
 /**
  * To start LM Studio server:
@@ -21,7 +22,7 @@ export type LocalModelResolverCapabilities = [Capability.Capability<typeof Commo
 const localModelResolver = Capability.makeModule<[], LocalModelResolverCapabilities>(() =>
   Effect.succeed([
     Capability.contributes(
-      Common.Capability.AiModelResolver,
+      AppCapabilities.AiModelResolver,
       LMStudioResolver.make().pipe(
         Layer.provide(
           OpenAiClient.layer({

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -4,9 +4,9 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
 import { AiContextBinder, AiConversation } from '@dxos/assistant';
-import { Agent } from '@dxos/assistant-toolkit';
+import { AgentFunctions, Chat } from '@dxos/assistant-toolkit';
 import { Blueprint, Prompt } from '@dxos/blueprints';
 import { type Queue } from '@dxos/client/echo';
 import { Filter, Obj, Ref, Type } from '@dxos/echo';
@@ -18,17 +18,17 @@ import { ClientCapabilities } from '@dxos/plugin-client';
 import { Collection } from '@dxos/schema';
 import { type Message } from '@dxos/types';
 
+import { AssistantBlueprint } from '../../blueprints';
 import { type AiChatServices, updateName } from '../../processor';
-import { Assistant, AssistantCapabilities, AssistantOperation } from '../../types';
-import { AssistantBlueprint, createBlueprint } from '../blueprint-definition/blueprint-definition';
+import { AssistantCapabilities, AssistantOperation } from '../../types';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    return Capability.contributes(Common.Capability.OperationResolver, [
+    return Capability.contributes(Capabilities.OperationResolver, [
       OperationResolver.make({
         operation: AssistantOperation.OnCreateSpace,
         handler: Effect.fnUntraced(function* ({ space, rootCollection }) {
-          const chatCollection = Collection.makeManaged({ key: Assistant.Chat.typename });
+          const chatCollection = Collection.makeManaged({ key: Chat.Chat.typename });
           const blueprintCollection = Collection.makeManaged({ key: Blueprint.Blueprint.typename });
           const promptCollection = Collection.makeManaged({ key: Type.getTypename(Prompt.Prompt) });
           Obj.change(rootCollection, (c) => {
@@ -36,7 +36,7 @@ export default Capability.makeModule(
           });
 
           // TODO(wittjosiah): Remove once function registry is avaiable.
-          space.db.add(serializeFunction(Agent.prompt));
+          space.db.add(serializeFunction(AgentFunctions.Prompt));
 
           // Create default chat.
           const { object: chat } = yield* Operation.invoke(AssistantOperation.CreateChat, { db: space.db });
@@ -45,21 +45,23 @@ export default Capability.makeModule(
       }),
       OperationResolver.make({
         operation: AssistantOperation.CreateChat,
-        handler: Effect.fnUntraced(function* ({ db, name }) {
-          const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+        handler: Effect.fnUntraced(function* ({ db, name, addToSpace = true }) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
           const client = yield* Capability.get(ClientCapabilities.Client);
           const space = client.spaces.get(db.spaceId);
           invariant(space, 'Space not found');
           const queue = space.queues.create();
-          const chat = Assistant.make({ name, queue: Ref.fromDXN(queue.dxn) });
-          space.db.add(chat);
+          const chat = Chat.make({ name, queue: Ref.fromDXN(queue.dxn) });
+          if (addToSpace) {
+            space.db.add(chat);
+          }
 
           // TODO(wittjosiah): This should be a space-level setting.
           // TODO(burdon): Clone when activated. Copy-on-write for template.
           const blueprints = yield* Effect.promise(() => db.query(Filter.type(Blueprint.Blueprint)).run());
-          let defaultBlueprint = blueprints.find((blueprint) => blueprint.key === AssistantBlueprint.Key);
+          let defaultBlueprint = blueprints.find((blueprint) => blueprint.key === AssistantBlueprint.key);
           if (!defaultBlueprint) {
-            defaultBlueprint = db.add(createBlueprint());
+            defaultBlueprint = db.add(AssistantBlueprint.make());
           }
 
           const binder = new AiContextBinder({ queue, registry });
@@ -73,7 +75,7 @@ export default Capability.makeModule(
       OperationResolver.make({
         operation: AssistantOperation.UpdateChatName,
         handler: Effect.fnUntraced(function* ({ chat }) {
-          const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
           const db = Obj.getDatabase(chat);
           const queue = chat.queue.target as Queue<Message.Message>;
           if (!db || !queue) {
@@ -99,7 +101,7 @@ export default Capability.makeModule(
         handler: Effect.fnUntraced(function* ({ companionTo, chat }) {
           const companionToId = Obj.getDXN(companionTo).toString();
           const chatId = chat && Obj.getDXN(chat).toString();
-          yield* Common.Capability.updateAtomValue(AssistantCapabilities.State, (current) => ({
+          yield* Capabilities.updateAtomValue(AssistantCapabilities.State, (current) => ({
             ...current,
             currentChat: { ...current.currentChat, [companionToId]: chatId },
           }));

package/src/capabilities/react-surface/react-surface.tsx

@@ -5,14 +5,16 @@
 import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { useSettingsState } from '@dxos/app-framework/react';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useSettingsState } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Chat, Initiative } from '@dxos/assistant-toolkit';
 import { Blueprint, Prompt } from '@dxos/blueprints';
 import { getSpace } from '@dxos/client/echo';
 import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
 import { Obj } from '@dxos/echo';
-import { Layout } from '@dxos/react-ui-mosaic';
+import { Layout } from '@dxos/react-ui';
 
 import {
   AssistantSettings,
@@ -20,41 +22,50 @@ import {
   ChatCompanion,
   ChatContainer,
   ChatDialog,
+  InitiativeContainer,
   PromptArticle,
+  TriggerStatus,
 } from '../../components';
 import { ASSISTANT_DIALOG, meta } from '../../meta';
-import { Assistant } from '../../types';
+import { type Assistant } from '../../types';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
-    Capability.contributes(Common.Capability.ReactSurface, [
-      Common.createSurface({
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
         id: `${meta.id}/plugin-settings`,
         role: 'article',
-        filter: (data): data is { subject: Common.Capability.Settings } =>
-          Common.Capability.isSettings(data.subject) && data.subject.prefix === meta.id,
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
         component: ({ data: { subject } }) => {
           const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
           return <AssistantSettings settings={settings} onSettingsChange={updateSettings} />;
         },
       }),
-      Common.createSurface({
+      Surface.create({
         id: `${meta.id}/chat`,
         role: 'article',
-        filter: (data): data is { subject: Assistant.Chat; variant: undefined } =>
-          Obj.instanceOf(Assistant.Chat, data.subject) && data.variant !== 'assistant-chat',
+        filter: (data): data is { subject: Chat.Chat; variant: undefined } =>
+          Obj.instanceOf(Chat.Chat, data.subject) && data.variant !== 'assistant-chat',
         component: ({ data, role, ref }) => <ChatContainer role={role} subject={data.subject} ref={ref} />,
       }),
+      Surface.create({
+        id: `${meta.id}/initiative`,
+        role: 'article',
+        filter: (data): data is { subject: Initiative.Initiative } =>
+          Obj.instanceOf(Initiative.Initiative, data.subject),
+        component: ({ data, role }) => <InitiativeContainer role={role} subject={data.subject} />,
+      }),
       // TODO(wittjosiah): This is flashing when chat changes.
-      Common.createSurface({
+      Surface.create({
         id: `${meta.id}/companion-chat`,
         role: 'article',
-        filter: (data): data is { companionTo: Obj.Unknown; subject: Assistant.Chat | 'assistant-chat' } =>
+        filter: (data): data is { companionTo: Obj.Unknown; subject: Chat.Chat | 'assistant-chat' } =>
           Obj.isObject(data.companionTo) &&
-          (Obj.instanceOf(Assistant.Chat, data.subject) || data.subject === 'assistant-chat'),
+          (Obj.instanceOf(Chat.Chat, data.subject) || data.subject === 'assistant-chat'),
         component: ({ data, role, ref }) => <ChatCompanion role={role} data={data} ref={ref} />,
       }),
-      Common.createSurface({
+      Surface.create({
         id: `${meta.id}/companion-invocations`,
         role: 'article',
         filter: (data): data is { companionTo: Sequence } =>
@@ -72,24 +83,29 @@ export default Capability.makeModule(() =>
           );
         },
       }),
-      Common.createSurface({
+      Surface.create({
         id: `${meta.id}/blueprint`,
         role: 'article',
         filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
         component: ({ data }) => <BlueprintArticle subject={data.subject} />,
       }),
-      Common.createSurface({
+      Surface.create({
         id: `${meta.id}/prompt`,
         role: 'article',
         filter: (data): data is { subject: Prompt.Prompt } => Obj.instanceOf(Prompt.Prompt, data.subject),
         component: ({ data }) => <PromptArticle subject={data.subject} />,
       }),
-      Common.createSurface({
+      Surface.create({
         id: ASSISTANT_DIALOG,
         role: 'dialog',
-        filter: (data): data is { props: { chat: Assistant.Chat } } => data.component === ASSISTANT_DIALOG,
+        filter: (data): data is { props: { chat: Chat.Chat } } => data.component === ASSISTANT_DIALOG,
         component: ({ data }) => <ChatDialog {...data.props} />,
       }),
+      Surface.create({
+        id: `${meta.id}/status`,
+        role: 'status',
+        component: () => <TriggerStatus />,
+      }),
     ]),
   ),
 );

package/src/capabilities/repair/repair.ts

@@ -5,14 +5,13 @@
 import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
+import { Chat } from '@dxos/assistant-toolkit';
 import { Blueprint, Prompt } from '@dxos/blueprints';
 import { Obj, Ref, Type } from '@dxos/echo';
 import { SpaceCapabilities } from '@dxos/plugin-space';
 import { type Space } from '@dxos/react-client/echo';
 import { Collection } from '@dxos/schema';
 
-import { Assistant } from '../../types';
-
 export default Capability.makeModule(() =>
   Effect.succeed(
     Capability.contributes(SpaceCapabilities.Repair, async ({ space }) => {
@@ -32,10 +31,10 @@ const ensureSystemCollections = async (space: Space) => {
 
   const objects = await Promise.all(rootCollection.objects.map((ref) => ref.load()));
   const chats = objects.find(
-    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Assistant.Chat.typename,
+    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Chat.Chat.typename,
   );
   if (!chats) {
-    const chatsCollectionRef = Ref.make(Collection.makeManaged({ key: Assistant.Chat.typename }));
+    const chatsCollectionRef = Ref.make(Collection.makeManaged({ key: Chat.Chat.typename }));
     Obj.change(rootCollection, (c) => {
       c.objects.push(chatsCollectionRef);
     });

package/src/capabilities/settings/settings.ts

@@ -4,7 +4,8 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { createKvsStore } from '@dxos/effect';
 
 import { meta } from '../../meta';
@@ -20,7 +21,7 @@ export default Capability.makeModule(() =>
 
     return [
       Capability.contributes(AssistantCapabilities.Settings, settingsAtom),
-      Capability.contributes(Common.Capability.Settings, {
+      Capability.contributes(AppCapabilities.Settings, {
         prefix: meta.id,
         schema: Assistant.Settings,
         atom: settingsAtom,

package/src/capabilities/toolkit/toolkit.ts

@@ -5,22 +5,23 @@
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { GenericToolkit } from '@dxos/assistant';
 import { AssistantToolkit, SystemToolkit, WebSearchToolkit } from '@dxos/assistant-toolkit';
 
 export default Capability.makeModule(() =>
   Effect.succeed([
     Capability.contributes(
-      Common.Capability.Toolkit,
+      AppCapabilities.Toolkit,
       GenericToolkit.make(AssistantToolkit.AssistantToolkit, AssistantToolkit.layer()),
     ),
 
     // TODO(burdon): How to manage dependencies across blueprints.
     Capability.contributes(
-      Common.Capability.Toolkit,
+      AppCapabilities.Toolkit,
       GenericToolkit.make(SystemToolkit.SystemToolkit, SystemToolkit.layer()),
     ),
-    Capability.contributes(Common.Capability.Toolkit, GenericToolkit.make(WebSearchToolkit, Layer.empty)),
+    Capability.contributes(AppCapabilities.Toolkit, GenericToolkit.make(WebSearchToolkit, Layer.empty)),
   ]),
 );

package/src/components/AssistantSettings/AssistantSettings.tsx

@@ -6,7 +6,7 @@ import React from 'react';
 
 import { DEFAULT_EDGE_MODELS, DEFAULT_OLLAMA_MODELS } from '@dxos/ai';
 import { Input, Select, useTranslation } from '@dxos/react-ui';
-import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
+import { Settings } from '@dxos/react-ui-form';
 
 import { meta } from '../../meta';
 import { type Assistant, LLM_PROVIDERS } from '../../types';
@@ -29,17 +29,17 @@ export const AssistantSettings = ({ settings, onSettingsChange }: AssistantSetti
   const { t } = useTranslation(meta.id);
 
   return (
-    <ControlPage>
-      <ControlSection title={t('settings title', { ns: meta.id })}>
-        <ControlGroup>
-          <ControlItemInput title={t('settings custom prompts label')}>
+    <Settings.Root>
+      <Settings.Section title={t('settings title', { ns: meta.id })}>
+        <Settings.Group>
+          <Settings.ItemInput title={t('settings custom prompts label')}>
             <Input.Switch
               checked={!!settings.customPrompts}
               onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, customPrompts: checked }))}
             />
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('settings llm provider label')}>
+          <Settings.ItemInput title={t('settings llm provider label')}>
             <Select.Root
               value={settings.llmProvider ?? 'edge'}
               onValueChange={(value) => {
@@ -64,9 +64,9 @@ export const AssistantSettings = ({ settings, onSettingsChange }: AssistantSetti
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('settings edge llm model label')}>
+          <Settings.ItemInput title={t('settings edge llm model label')}>
             <Select.Root
               value={settings.edgeModel ?? DEFAULT_VALUE}
               onValueChange={(value) => {
@@ -88,9 +88,9 @@ export const AssistantSettings = ({ settings, onSettingsChange }: AssistantSetti
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('settings ollama llm model label')}>
+          <Settings.ItemInput title={t('settings ollama llm model label')}>
             <Select.Root
               value={settings.ollamaModel ?? DEFAULT_VALUE}
               onValueChange={(value) => {
@@ -112,9 +112,9 @@ export const AssistantSettings = ({ settings, onSettingsChange }: AssistantSetti
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
-        </ControlGroup>
-      </ControlSection>
-    </ControlPage>
+          </Settings.ItemInput>
+        </Settings.Group>
+      </Settings.Section>
+    </Settings.Root>
   );
 };

package/src/components/BlueprintArticle.tsx

@@ -4,12 +4,11 @@
 
 import React from 'react';
 
-import { type SurfaceComponentProps } from '@dxos/app-framework/react';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
 import { type Blueprint } from '@dxos/blueprints';
 import { Obj } from '@dxos/echo';
-import { Toolbar } from '@dxos/react-ui';
+import { Layout, Toolbar } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
-import { Layout } from '@dxos/react-ui-mosaic';
 
 import { TemplateEditor } from './TemplateEditor';