@dxos/plugin-assistant 0.8.4-main.f5c0578 → 0.8.4-main.fcfe5033a5

package/src/capabilities/index.ts

@@ -2,15 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/operation';
 
-export * from './capabilities';
-
-export const AiService = lazy(() => import('./ai-service'));
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
-export const EdgeModelResolver = lazy(() => import('./edge-model-resolver'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const Settings = lazy(() => import('./settings'));
-export const Toolkit = lazy(() => import('./toolkit'));
+export const AiService = Capability.lazy('AiService', () => import('./ai-service'));
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const CompanionChatProvisioner = Capability.lazy(
+  'CompanionChatProvisioner',
+  () => import('./companion-chat-provisioner'),
+);
+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 Migrations = Capability.lazy('AssistantMigrations', () => import('./migrations'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const Settings = Capability.lazy('Settings', () => import('./settings'));
+export const AssistantState = Capability.lazy('AssistantState', () => import('./state'));
+export const Toolkit = Capability.lazy('Toolkit', () => import('./toolkit'));

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

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as OpenAiClient from '@effect/ai-openai/OpenAiClient';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { LMStudioResolver, OllamaResolver } from '@dxos/ai/resolvers';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+
+/**
+ * To start LM Studio server:
+ * ```bash
+ * ~/.lmstudio/bin/lms server start --cors
+ * ```
+ *
+ * To start Ollama server:
+ * ```bash
+ * OLLAMA_ORIGINS="*" ollama serve
+ * ```
+ */
+const localModelResolver = Capability.makeModule<[]>(() =>
+  Effect.succeed([
+    Capability.contributes(
+      AppCapabilities.AiModelResolver,
+      LMStudioResolver.make().pipe(
+        Layer.provide(
+          OpenAiClient.layer({
+            apiUrl: LMStudioResolver.DEFAULT_LMSTUDIO_ENDPOINT,
+          }),
+        ),
+        Layer.provide(FetchHttpClient.layer),
+      ),
+    ),
+    Capability.contributes(
+      AppCapabilities.AiModelResolver,
+      OllamaResolver.make({
+        transformClient: HttpClient.withTracerPropagation(false),
+      }).pipe(Layer.provide(FetchHttpClient.layer)),
+    ),
+  ]),
+);
+
+export default localModelResolver;

package/src/capabilities/markdown.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown';
+
+import { AssistantOperation } from '#operations';
+
+import { promptRunExtension } from '../extensions';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilities = yield* Capability.Service;
+
+    return Capability.contributes(MarkdownCapabilities.Extensions, [
+      ({ document: doc }) => {
+        if (!doc) {
+          return undefined;
+        }
+
+        const db = Obj.getDatabase(doc);
+        if (!db) {
+          return undefined;
+        }
+
+        const { invokePromise } = capabilities.get(Capabilities.OperationInvoker);
+
+        return promptRunExtension({
+          onRun: (promptText) => {
+            void invokePromise(AssistantOperation.RunPromptInNewChat, { db, prompt: promptText });
+          },
+        });
+      },
+    ]);
+  }),
+);

package/src/capabilities/migrations.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Chat, ResearchGraph } from '@dxos/assistant-toolkit';
+import { defineObjectMigration } from '@dxos/client/echo';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+
+const identityTransform = async (from: any) => ({ ...from });
+const noopCallback = async () => {};
+
+const migrations = [
+  defineObjectMigration({
+    from: Chat.LegacyCompanionTo,
+    to: Chat.CompanionTo,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  defineObjectMigration({
+    from: ResearchGraph.LegacyResearchGraph,
+    to: ResearchGraph.ResearchGraphV1,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+  ...ResearchGraph.migrations,
+];
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(ClientCapabilities.Migration, migrations);
+  }),
+);

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/operation';
+
+import { AssistantOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, AssistantOperationHandlerSet);
+  }),
+);

package/src/capabilities/react-surface.tsx

@@ -2,144 +2,153 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
-import React, { useCallback, useEffect } from 'react';
+import * as Effect from 'effect/Effect';
+import React, { type ComponentProps } from 'react';
 
-import { Capabilities, contributes, createIntent, createSurface, useIntentDispatcher } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/blueprints';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useSettingsState } from '@dxos/app-framework/ui';
+import { AppSurface, useActiveSpace } from '@dxos/app-toolkit/ui';
+import { Chat, Agent } 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 { Filter, Obj, Query, Ref } from '@dxos/echo';
-import { SettingsStore } from '@dxos/local-storage';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { StackItem } from '@dxos/react-ui-stack';
+import { Feed, Obj } from '@dxos/echo';
+import { Panel } from '@dxos/react-ui';
 
+import { AssistantSettings } from '#components';
 import {
-  AssistantSettings,
-  BlueprintContainer,
+  BlueprintArticle,
+  ChatCompanion,
   ChatContainer,
   ChatDialog,
-  PromptSettings,
-  SequenceContainer,
-} from '../components';
-import { type AiChatProcessor } from '../hooks';
-import { ASSISTANT_DIALOG, meta } from '../meta';
-import { Assistant, AssistantAction } from '../types';
+  AgentArticle,
+  AgentProperties,
+  PromptArticle,
+  PromptList,
+  TracePanel,
+  TriggerStatus,
+} from '#containers';
+import { ASSISTANT_COMPANION_VARIANT, ASSISTANT_DIALOG, meta } from '#meta';
+import { type Assistant } from '#types';
 
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${meta.id}/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<Assistant.Settings> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
-      component: ({ data: { subject } }) => <AssistantSettings settings={subject.value} />,
-    }),
-    createSurface({
-      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',
-      component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/object-chat`,
-      role: 'article',
-      filter: (data): data is { companionTo: Obj.Any; subject: Assistant.Chat | 'assistant-chat' } =>
-        Obj.isObject(data.companionTo) &&
-        (Obj.instanceOf(Assistant.Chat, data.subject) || data.subject === 'assistant-chat'),
-      component: ({ data, role }) => {
-        const { dispatch } = useIntentDispatcher();
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: 'plugin-settings',
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Assistant.Settings>(subject.atom);
+          return <AssistantSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Surface.create({
+        id: 'chat',
+        role: 'article',
+        filter: (data): data is { attendableId: string; subject: Chat.Chat; variant: undefined } =>
+          typeof data.attendableId === 'string' &&
+          Obj.instanceOf(Chat.Chat, data.subject) &&
+          data.variant !== ASSISTANT_COMPANION_VARIANT,
+        component: ({ data, role, ref }) => {
+          return <ChatContainer role={role} subject={data.subject} attendableId={data.attendableId} ref={ref} />;
+        },
+      }),
+      Surface.create({
+        id: 'agent',
+        filter: AppSurface.object(AppSurface.Article, Agent.Agent),
+        component: ({ data, role }) => (
+          <AgentArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: 'agent-properties',
+        filter: AppSurface.object(AppSurface.ObjectProperties, Agent.Agent),
+        component: ({ data }) => <AgentProperties subject={data.subject} />,
+      }),
+      Surface.create({
+        id: 'companion-chat',
+        role: 'article',
+        filter: (data): data is { subject: Chat.Chat | null; attendableId: string; companionTo: Obj.Unknown } =>
+          typeof data.attendableId === 'string' &&
+          Obj.isObject(data.companionTo) &&
+          (Obj.instanceOf(Chat.Chat, data.subject) || data.subject === null),
+        component: ({ data: { subject, attendableId, companionTo }, role, ref }) => (
+          <ChatCompanion
+            role={role}
+            subject={subject}
+            attendableId={attendableId}
+            companionTo={companionTo}
+            ref={ref}
+          />
+        ),
+      }),
+      Surface.create({
+        id: 'companion-invocations',
+        role: 'article',
+        filter: (data): data is { companionTo: Sequence } =>
+          (Obj.instanceOf(Sequence, data.companionTo) || Obj.instanceOf(Prompt.Prompt, data.companionTo)) &&
+          data.subject === 'invocations',
+        component: ({ data, role }) => {
+          const space = getSpace(data.companionTo);
+          const feed = space?.properties.invocationTraceFeed?.target;
+          const queueDxn = feed ? Feed.getQueueDxn(feed) : undefined;
+          // TODO(wittjosiah): Support invocation filtering for prompts.
+          const target = Obj.instanceOf(Prompt.Prompt, data.companionTo) ? undefined : data.companionTo;
 
-        // Initialize companion chat if it doesn't exist.
-        // TODO(wittjosiah): Factor out to container.
-        useEffect(() => {
-          const timeout = setTimeout(async () => {
-            const space = getSpace(data.companionTo);
-            if (space && data.subject === 'assistant-chat') {
-              const result = await space.db
-                .query(Query.select(Filter.ids(data.companionTo.id)).targetOf(Assistant.CompanionTo).source())
-                .run();
-              if (result.objects.length > 0) {
-                return;
-              }
+          return (
+            <Panel.Root role={role} className='dx-document'>
+              <Panel.Content asChild>
+                <InvocationTraceContainer db={space?.db} queueDxn={queueDxn} target={target} detailAxis='block' />
+              </Panel.Content>
+            </Panel.Root>
+          );
+        },
+      }),
+      Surface.create({
+        id: 'blueprint',
+        filter: AppSurface.object(AppSurface.Article, Blueprint.Blueprint),
+        component: ({ data, role }) => (
+          <BlueprintArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: 'prompt',
+        filter: AppSurface.object(AppSurface.Article, Prompt.Prompt),
+        component: ({ data, role }) => (
+          <PromptArticle role={role} subject={data.subject} attendableId={data.attendableId} />
+        ),
+      }),
+      Surface.create({
+        id: ASSISTANT_DIALOG,
+        filter: AppSurface.component<ComponentProps<typeof ChatDialog>>(AppSurface.Dialog, ASSISTANT_DIALOG),
+        component: ({ data }) => <ChatDialog {...data.props} />,
+      }),
+      Surface.create({
+        id: 'trace',
+        filter: AppSurface.literal(Surface.makeType<{ subject: string }>('deck-companion--trace'), 'trace'),
+        component: () => {
+          const space = useActiveSpace();
+          if (!space) {
+            return null;
+          }
 
-              const program = Effect.gen(function* () {
-                const { object } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
-                yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-                yield* dispatch(
-                  createIntent(SpaceAction.AddRelation, {
-                    space,
-                    schema: Assistant.CompanionTo,
-                    source: object,
-                    target: data.companionTo,
-                  }),
-                );
-              });
-
-              void Effect.runPromise(program);
-            }
-          });
-
-          return () => clearTimeout(timeout);
-        }, [data.subject]);
-
-        // TODO(wittjosiah): Factor out to container.
-        const handleProcessorReady = useCallback(
-          (processor: AiChatProcessor) => {
-            if (Obj.instanceOf(Blueprint.Blueprint, data.companionTo)) {
-              void processor.context.bind({ blueprints: [Ref.make(data.companionTo)] });
-            } else {
-              void processor.context.bind({ objects: [Ref.make(data.companionTo)] });
-            }
-          },
-          [data.companionTo],
-        );
-
-        if (data.subject === 'assistant-chat') {
-          return null;
-        }
-
-        return <ChatContainer role={role} chat={data.subject} onProcessorReady={handleProcessorReady} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/sequence`,
-      role: 'article',
-      filter: (data): data is { subject: Sequence } => Obj.instanceOf(Sequence, data.subject),
-      component: ({ data }) => <SequenceContainer sequence={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/companion/logs`,
-      role: 'article',
-      filter: (data): data is { companionTo: Sequence } =>
-        Obj.instanceOf(Sequence, data.companionTo) && data.subject === 'logs',
-      component: ({ data, role }) => {
-        const space = getSpace(data.companionTo);
-        return (
-          <StackItem.Content>
-            <InvocationTraceContainer space={space} target={data.companionTo} detailAxis='block' />
-          </StackItem.Content>
-        );
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/blueprint`,
-      role: 'article',
-      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
-      component: ({ data }) => <BlueprintContainer blueprint={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/prompt-settings`,
-      role: 'object-settings',
-      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
-      component: ({ data }) => <PromptSettings template={data.subject.instructions} />,
-    }),
-    createSurface({
-      id: ASSISTANT_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: { chat: Assistant.Chat } } => data.component === ASSISTANT_DIALOG,
-      component: ({ data }) => <ChatDialog {...data.props} />,
-    }),
-  ]);
+          return <TracePanel space={space} />;
+        },
+      }),
+      Surface.create({
+        id: 'status',
+        role: 'status-indicator',
+        component: () => <TriggerStatus />,
+      }),
+      Surface.create({
+        id: 'prompts',
+        filter: AppSurface.subject(
+          Surface.makeType<{ subject: Obj.Any; attendableId: string }>('prompts'),
+          Obj.isObject,
+        ),
+        component: ({ data }) => <PromptList subject={data.subject} />,
+      }),
+    ]),
+  ),
+);

package/src/capabilities/settings.ts

@@ -2,18 +2,30 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
+import * as Effect from 'effect/Effect';
 
-import { meta } from '../meta';
-import { Assistant } from '../types';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
 
-export default () => {
-  const settings = live<Assistant.Settings>({});
+import { meta } from '#meta';
+import { Assistant, AssistantCapabilities } from '#types';
 
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: Assistant.Settings,
-    value: settings,
-  });
-};
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Assistant.Settings,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(AssistantCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Assistant.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/state.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { type Obj } from '@dxos/echo';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '#meta';
+import { AssistantCapabilities } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    // NOTE: This needs to be a chat object rather than a string id to avoid a query race.
+    // TODO(wittjosiah): Handle serialization and hydration for this so it can be cached.
+    const stateAtom = createKvsStore({
+      key: meta.id,
+      schema: AssistantCapabilities.StateSchema,
+      defaultValue: () => ({
+        currentChat: {},
+        pendingPrompts: {},
+      }),
+    });
+
+    const companionChatCacheAtom = Atom.make<Record<string, Obj.Unknown | undefined>>({}).pipe(Atom.keepAlive);
+
+    return [
+      Capability.contributes(AssistantCapabilities.State, stateAtom),
+      Capability.contributes(AssistantCapabilities.CompanionChatCache, companionChatCacheAtom),
+    ];
+  }),
+);

package/src/capabilities/toolkit.ts

@@ -2,105 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AiTool, AiToolkit } from '@effect/ai';
-import { Effect, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
 
-import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { Filter, Obj, Type } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { SpaceCapabilities, getActiveSpace } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { DataType } from '@dxos/schema';
-import { trim } from '@dxos/util';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { WebSearchToolkitOpaque } from '@dxos/assistant-toolkit';
 
-class SchemaToolkit extends AiToolkit.make(
-  AiTool.make('get-schemas', {
-    description: trim`
-      Retrieves schemas definitions.
-    `,
-    parameters: {
-      // TODO(wittjosiah): Remove this once parameter-less tools are fixed.
-      limit: Schema.Number,
-    },
-    // TODO(dmaretskyi): Effect returns ({ result, encodedResult })
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-  AiTool.make('create-record', {
-    description: trim`
-      Creates a new record.
-      Get the schema from the get-schemas tool and ensure that the data matches the corresponding schema.
-      Note that only record schemas are supported.
-    `,
-    parameters: {
-      typename: Schema.String,
-      data: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-) {
-  static layer = (context: PluginContext) =>
-    SchemaToolkit.toLayer({
-      //
-      'get-schemas': () => {
-        const space = getActiveSpace(context);
-        const service = space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable;
-        return Effect.gen(function* () {
-          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
-            typename: Type.getTypename(form.objectSchema),
-            jsonSchema: Type.toJsonSchema(form.objectSchema),
-            kind: 'item',
-          }));
-          const allowed = context
-            .getCapabilities(ClientCapabilities.SchemaWhiteList)
-            .flat()
-            .map((schema) => ({
-              typename: Type.getTypename(schema),
-              jsonSchema: Type.toJsonSchema(schema),
-              kind: 'record',
-            }));
-          const schemas = [...forms, ...allowed];
-          if (space) {
-            const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-            schemas.push(
-              ...objects.map((object) => ({
-                typename: object.typename,
-                jsonSchema: object.jsonSchema,
-                kind: 'record',
-              })),
-            );
-          }
-          return schemas.map((schema) => schema.typename);
-        }).pipe(Effect.provide(service));
-      },
-
-      //
-      'create-record': ({ typename, data }) => {
-        const space = getActiveSpace(context);
-        const service = space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable;
-        console.log('create-record', { typename, data, space });
-        return Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const schemas = context.getCapabilities(ClientCapabilities.SchemaWhiteList).flat();
-          const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-          schemas.push(...objects.map((object) => Type.toEffectSchema(object.jsonSchema)));
-
-          const schema = schemas.find((schema) => Type.getTypename(schema) === typename);
-          if (!schema) {
-            throw new Error(`Schema not found for ${typename}`);
-          }
-
-          const object = Obj.make(schema, data);
-          yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space!, hidden: true }));
-          return object;
-        }).pipe(Effect.provide(service), Effect.orDie);
-      },
-    });
-}
-
-export default (context: PluginContext) => [
-  contributes(Capabilities.Toolkit, SchemaToolkit),
-  contributes(Capabilities.ToolkitHandler, SchemaToolkit.layer(context)),
-];
+export default Capability.makeModule(() =>
+  Effect.succeed([Capability.contributes(AppCapabilities.Toolkit, WebSearchToolkitOpaque)]),
+);