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

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

@@ -0,0 +1,164 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Registry } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Graph, type Node } from '@dxos/app-graph';
+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';
+import { getLinkedVariant } from '@dxos/react-ui-attention';
+import { byPosition } from '@dxos/util';
+
+import { ASSISTANT_COMPANION_VARIANT } from '#meta';
+import { AssistantCapabilities, AssistantOperation } from '#types';
+
+/**
+ * Non-React capability that watches deck companion state and provisions transient chats
+ * for active planks when the assistant companion is selected.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const operationInvoker = yield* Capability.get(Capabilities.OperationInvoker);
+    const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+    const registry: Registry.Registry = yield* Capability.get(Capabilities.AtomRegistry);
+    const deckStateAtom = yield* Capability.get(DeckCapabilities.State);
+    const cacheAtom = yield* Capability.get(AssistantCapabilities.CompanionChatCache);
+    const stateAtom = yield* Capability.get(AssistantCapabilities.State);
+
+    const plankSubs = new Map<string, () => void>();
+
+    /** Unsubscribe a single plank and remove it from the map. */
+    const unsubPlank = (plankId: string) => {
+      plankSubs.get(plankId)?.();
+      plankSubs.delete(plankId);
+    };
+
+    /** Unsubscribe all per-plank subscriptions. */
+    const unsubAllPlanks = () => {
+      for (const unsub of plankSubs.values()) {
+        unsub();
+      }
+      plankSubs.clear();
+    };
+
+    /**
+     * Attempt to provision for a single plank.
+     * Returns true when the plank is resolved (provisioned or already cached)
+     * so the caller can tear down the connection subscription.
+     */
+    const provisionForPlank = (plankId: string, companionVariant: string | undefined): boolean => {
+      const node: Node.Node | null = Graph.getNode(graph, plankId).pipe(Option.getOrNull);
+      if (!node || !Obj.isObject(node.data) || Obj.instanceOf(Chat.Chat, node.data)) {
+        return false;
+      }
+
+      if (resolveEffectiveVariant(graph, plankId, companionVariant) !== ASSISTANT_COMPANION_VARIANT) {
+        return false;
+      }
+
+      const object = node.data;
+      const companionUri = Obj.getURI(object);
+      const cache = registry.get(cacheAtom);
+      if (cache[companionUri]) {
+        return true;
+      }
+
+      const db = Obj.getDatabase(object);
+      if (!db) {
+        log.warn('No db for object', { plankId, companionUri });
+        return false;
+      }
+
+      void operationInvoker
+        .invokePromise(AssistantOperation.EnsureCompanionChat, { db, companionTo: object })
+        .catch((error) => log.warn('Failed to provision companion chat', { plankId, error }));
+
+      return false;
+    };
+
+    const provision = () => {
+      const deckState: StoredDeckState = registry.get(deckStateAtom);
+      const deck = deckState.decks[deckState.activeDeck];
+      if (!deck?.companionOpen) {
+        unsubAllPlanks();
+        return;
+      }
+
+      const plankIds = new Set(deck.solo ? [deck.solo] : deck.active);
+
+      // Remove subscriptions for planks that are no longer active.
+      for (const trackedId of plankSubs.keys()) {
+        if (!plankIds.has(trackedId)) {
+          unsubPlank(trackedId);
+        }
+      }
+
+      for (const plankId of plankIds) {
+        const resolved = provisionForPlank(plankId, deck.companionVariant);
+
+        if (resolved) {
+          // Already provisioned — no need to watch connections.
+          unsubPlank(plankId);
+        } else if (!plankSubs.has(plankId)) {
+          // Not yet resolved — subscribe to child connections so we re-try
+          // when graph builder extensions add companion nodes (after expand).
+          plankSubs.set(
+            plankId,
+            registry.subscribe(graph.connections(plankId, 'child'), () => {
+              if (provisionForPlank(plankId, deck.companionVariant)) {
+                unsubPlank(plankId);
+              }
+            }),
+          );
+        }
+      }
+    };
+
+    provision();
+
+    const unsub1 = registry.subscribe(deckStateAtom, provision);
+    const unsub2 = registry.subscribe(stateAtom, provision);
+
+    return Capability.contributes(Capabilities.Null, null, () =>
+      Effect.sync(() => {
+        unsub1();
+        unsub2();
+        unsubAllPlanks();
+      }),
+    );
+  }),
+);
+
+/**
+ * Mirrors useSelectedCompanion fallback logic outside of React.
+ * Returns the variant that would actually be rendered for a given plank.
+ */
+const resolveEffectiveVariant = (
+  graph: Graph.BaseGraph,
+  plankId: string,
+  preferredVariant: string | undefined,
+): string | undefined => {
+  const companions = Graph.getConnections(graph, plankId, 'child')
+    .filter((node) => node.type === PLANK_COMPANION_TYPE)
+    .toSorted((a, b) => byPosition(a.properties, b.properties));
+
+  if (companions.length === 0) {
+    return undefined;
+  }
+
+  if (preferredVariant) {
+    const preferred = companions.find((companion) => getLinkedVariant(companion.id) === preferredVariant);
+    if (preferred) {
+      return getLinkedVariant(preferred.id);
+    }
+  }
+
+  return getLinkedVariant(companions[0].id);
+};

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

@@ -2,28 +2,69 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AnthropicClient } from '@effect/ai-anthropic';
-import { FetchHttpClient } from '@effect/platform';
-import { Layer } from 'effect';
-
-import { AiServiceRouter } from '@dxos/ai';
-import { contributes } from '@dxos/app-framework';
-
-import { AssistantCapabilities } from './capabilities';
-
-export default () => {
-  return [
-    contributes(
-      AssistantCapabilities.AiModelResolver,
-      AiServiceRouter.AnthropicResolver.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),
-      ),
-    ),
-  ];
-};
+import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
+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';
+
+import { ANTHROPIC_SOURCE } from '../constants';
+
+// 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,
+      anthropicResolverLayer,
+      () => Effect.sync(() => identitySubscription?.unsubscribe()),
+    );
+
+    return [contribution];
+  }),
+);
+
+export default edgeModelResolver;

package/src/capabilities/index.ts

@@ -2,15 +2,45 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
 
-export * from './capabilities';
+import type { AssistantPluginOptions } from '#types';
 
-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 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-extension'));
+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/integration-provider.ts

@@ -0,0 +1,86 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Obj, Ref } from '@dxos/echo';
+import {
+  type CredentialForm,
+  Integration,
+  IntegrationProvider as IntegrationProviderCapability,
+} from '@dxos/plugin-integration';
+import { AccessToken } from '@dxos/types';
+
+import { ANTHROPIC_PROVIDER_ID, ANTHROPIC_SOURCE } from '../constants';
+
+/** API-key form for the Anthropic BYOK provider; key is best-effort validated against `/v1/models`. */
+const AnthropicTokenForm = Schema.Struct({
+  token: Schema.String.annotations({
+    title: 'API key',
+    description: 'Your Anthropic API key — find it at https://console.anthropic.com/settings/keys.',
+  }),
+});
+
+/**
+ * Best-effort validation: 401/403 from Anthropic blocks the save; CORS/network failures
+ * are tolerated so the form still works in environments where the direct browser call is blocked.
+ */
+const validateAnthropicKey = (apiKey: string): Effect.Effect<void, Error> =>
+  Effect.tryPromise({
+    try: () =>
+      fetch('https://api.anthropic.com/v1/models', {
+        headers: {
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01',
+          'anthropic-dangerous-direct-browser-access': 'true',
+        },
+      }),
+    catch: (cause) => cause,
+  }).pipe(
+    Effect.matchEffect({
+      onSuccess: (response) =>
+        response.status === 401 || response.status === 403
+          ? Effect.fail(
+              new Error('Invalid Anthropic API key. Check it at https://console.anthropic.com/settings/keys.'),
+            )
+          : Effect.void,
+      onFailure: () => Effect.void,
+    }),
+  );
+
+const credentialForm: CredentialForm<Schema.Schema.Type<typeof AnthropicTokenForm>> = {
+  schema: AnthropicTokenForm,
+  defaultValues: { token: '' },
+  // Validates before the dialog closes so 401/403 errors are shown inline.
+  onValidate: ({ values }) => validateAnthropicKey(values.token.trim()),
+  onSubmit: ({ values, provider }) =>
+    Effect.sync(() => {
+      const accessToken = Obj.make(AccessToken.AccessToken, {
+        source: ANTHROPIC_SOURCE,
+        token: values.token.trim(),
+      });
+      const integration = Obj.make(Integration.Integration, {
+        name: provider.label ?? 'Anthropic',
+        providerId: provider.id,
+        accessToken: Ref.make(accessToken),
+        targets: [],
+      });
+      return { kind: 'complete' as const, accessToken, integration };
+    }),
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(IntegrationProviderCapability, [
+      {
+        id: ANTHROPIC_PROVIDER_ID,
+        source: ANTHROPIC_SOURCE,
+        label: 'Anthropic',
+        credentialForm,
+      },
+    ]);
+  }),
+);

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-extension.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/types';
+
+import { AssistantOperation } from '#types';
+
+import { promptRunExtension } from '../extensions';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilities = yield* Capability.Service;
+
+    return Capability.contributes(MarkdownCapabilities.ExtensionProvider, [
+      ({ 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,28 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Chat } from '@dxos/assistant-toolkit';
+import { Migration } from '@dxos/echo';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+const identityTransform = async (from: any) => ({ ...from });
+const noopCallback = async () => {};
+
+const migrations = [
+  Migration.define({
+    from: Chat.LegacyCompanionTo,
+    to: Chat.CompanionTo,
+    transform: identityTransform,
+    onMigration: noopCallback,
+  }),
+];
+
+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/compute';
+
+import { AssistantOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, AssistantOperationHandlerSet);
+  }),
+);