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

package/src/capabilities/ai-service.ts

@@ -2,27 +2,49 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Effect, Layer } from 'effect';
-
-import { AiServiceRouter } from '@dxos/ai';
-import { type PluginContext, contributes } from '@dxos/app-framework';
-
-import { AssistantCapabilities } from './capabilities';
-
-export default (context: PluginContext) => {
-  const resolvers = context.getCapabilities(AssistantCapabilities.AiModelResolver);
-
-  // TODO(dmaretskyi): Extract function to reduce them.
-  const combinedLayer = resolvers.reduce(
-    (acc, resolver) => resolver.pipe(Layer.provide(acc)),
-    AiServiceRouter.AiModelResolver.fromModelMap(Effect.succeed({})), // Empty resolver as fallback.
-  );
-
-  return [
-    // TODO(dmaretskyi): Read config from settings.
-    contributes(
-      AssistantCapabilities.AiServiceLayer,
-      AiServiceRouter.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer)),
-    ),
-  ];
-};
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { AiModelResolver, AiService } from '@dxos/ai';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Credential, LayerSpec } from '@dxos/compute';
+
+import type { AssistantPluginOptions } from '#types';
+
+export default Capability.makeModule<AssistantPluginOptions | void, Capability.Any[]>(
+  Effect.fnUntraced(function* (options) {
+    const resolvers = yield* Capability.getAll(AppCapabilities.AiModelResolver);
+
+    // TODO(dmaretskyi): Extract function to reduce them.
+    const combinedLayer = resolvers.reduce(
+      (acc, resolver) => resolver.pipe(Layer.provide(acc)),
+      AiModelResolver.AiModelResolver.fromModelMap({ name: 'Fallback' }, Effect.succeed({})), // Empty resolver as fallback.
+    );
+
+    let aiServiceLayer: Layer.Layer<AiService.AiService, never, Credential.CredentialsService> =
+      AiModelResolver.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer));
+
+    const aiServiceMiddleware = options?.aiServiceMiddleware;
+    if (aiServiceMiddleware) {
+      aiServiceLayer = aiServiceLayer.pipe(
+        Layer.map((context) => {
+          const aiService = Context.get(context, AiService.AiService);
+          return Context.make(AiService.AiService, aiServiceMiddleware(aiService));
+        }),
+      );
+    }
+
+    const aiServiceSpec = LayerSpec.make(
+      {
+        affinity: 'space',
+        requires: [Credential.CredentialsService],
+        provides: [AiService.AiService],
+      },
+      () => aiServiceLayer,
+    );
+
+    return [Capability.contributes(Capabilities.LayerSpec, aiServiceSpec)];
+  }),
+);

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

@@ -2,168 +2,236 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import { Option, pipe } from 'effect';
+import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
+import * as Option from 'effect/Option';
 
+import { Capability } from '@dxos/app-framework';
 import {
-  Capabilities,
-  LayoutAction,
-  type PluginContext,
-  type PromiseIntentDispatcher,
-  contributes,
-  createIntent,
-} from '@dxos/app-framework';
+  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 { Obj } from '@dxos/echo';
+import { DXN, Database, Filter, Obj, Query, Type, type Ref } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
-import { ROOT_ID, createExtension } from '@dxos/plugin-graph';
-import { getActiveSpace, rxFromQuery } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { Filter, Query, type QueryResult, type Space, fullyQualifiedId, getSpace } from '@dxos/react-client/echo';
-
-import { ASSISTANT_DIALOG, meta } from '../meta';
-import { Assistant, AssistantAction } from '../types';
-
-export default (context: PluginContext) =>
-  contributes(Capabilities.AppGraphBuilder, [
-    createExtension({
-      id: `${meta.id}/assistant`,
-      actions: (node) =>
-        Rx.make((get) =>
-          pipe(
-            get(node),
-            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
-            Option.map(() => [
-              {
-                id: `${LayoutAction.UpdateDialog._tag}/assistant/open`,
-                data: async () => {
-                  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-                  const client = context.getCapability(ClientCapabilities.Client);
-                  const space = getActiveSpace(context) ?? client.spaces.default;
-                  const chat = await getOrCreateChat(dispatch, space);
-                  if (!chat) {
-                    return;
-                  }
+import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
+import { SpaceOperation } from '@dxos/plugin-space';
+import { linkedSegment } from '@dxos/react-ui-attention';
 
-                  await dispatch(
-                    createIntent(LayoutAction.UpdateDialog, {
-                      part: 'dialog',
-                      subject: ASSISTANT_DIALOG,
-                      options: {
-                        state: true,
-                        blockAlign: 'end',
-                        props: {
-                          chat,
-                        },
-                      },
-                    }),
-                  );
-                },
-                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',
-                  },
-                },
+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(
+  NodeMatcher.whenEchoObject,
+  NodeMatcher.whenNot(NodeMatcher.whenEchoTypeMatches(Chat.Chat)),
+);
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilities = yield* Capability.Service;
+
+    const extensions = yield* Effect.all([
+      GraphBuilder.createTypeExtension({
+        id: 'root',
+        type: Chat.Chat,
+        actions: (chat) => {
+          return Effect.succeed([
+            Node.makeAction({
+              id: AssistantOperation.UpdateChatName.meta.key,
+              data: () =>
+                Effect.gen(function* () {
+                  // TODO(dmaretskyi): This goes away when composer will have unified operation invocations.
+                  const db = Obj.getDatabase(chat);
+                  invariant(db);
+                  yield* Operation.invoke(AssistantOperation.UpdateChatName, { chat }, { spaceId: db.spaceId });
+                }),
+              properties: {
+                label: ['chat-update-name.label', { ns: meta.id }],
+                icon: 'ph--magic-wand--regular',
+                disposition: 'list-item',
               },
-            ]),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-
-    createExtension({
-      id: `${meta.id}/object-chat-companion`,
-      connector: (node) => {
-        let query: QueryResult<Assistant.Chat> | undefined;
-        return Rx.make((get) => {
-          const nodeOption = get(node);
-          if (Option.isNone(nodeOption)) {
-            return [];
-          }
-
-          const object = nodeOption.value.data;
-          if (!Obj.isObject(object)) {
-            return [];
-          }
-
-          const space = getSpace(object);
-          if (!space) {
-            return [];
-          }
-
-          if (!query) {
-            query = space.db.query(Query.select(Filter.ids(object.id)).targetOf(Assistant.CompanionTo).source());
-          }
-
-          const chat = get(rxFromQuery(query))[0];
-          return [
-            {
-              id: [fullyQualifiedId(object), 'assistant-chat'].join(ATTENDABLE_PATH_SEPARATOR),
-              type: PLANK_COMPANION_TYPE,
-              data: chat ?? 'assistant-chat',
+            }),
+          ]);
+        },
+      }),
+
+      GraphBuilder.createExtension({
+        id: 'assistant',
+        match: NodeMatcher.whenRoot,
+        actions: () =>
+          Effect.succeed([
+            Node.makeAction({
+              id: 'importComputeOperations',
+              data: Effect.fnUntraced(function* () {
+                const capabilities = yield* Capability.Service;
+                const client = yield* Capability.get(ClientCapabilities.Client);
+                const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+                if (!space) {
+                  return;
+                }
+                for (const definition of computeOperationsToImport) {
+                  const key = definition.meta.key;
+                  if (!key) {
+                    continue;
+                  }
+                  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* Database.flush();
+              }),
               properties: {
-                label: ['assistant chat label', { ns: meta.id }],
-                icon: 'ph--sparkle--regular',
-                position: 'hoist',
-                disposition: 'hidden',
+                label: ['import-compute-operations.label', { ns: meta.id }],
+                icon: 'ph--download-simple--regular',
               },
-            },
-          ];
-        });
-      },
-    }),
-
-    createExtension({
-      id: `${meta.id}/sequence-logs`,
-      connector: (node) =>
-        Rx.make((get) =>
-          pipe(
-            get(node),
-            Option.flatMap((node) => (Obj.instanceOf(Sequence, node.data) ? Option.some(node) : Option.none())),
-            Option.map((node) => [
-              {
-                id: [node.id, 'logs'].join(ATTENDABLE_PATH_SEPARATOR),
-                type: PLANK_COMPANION_TYPE,
-                data: 'logs',
-                properties: {
-                  label: ['sequence logs label', { ns: meta.id }],
-                  icon: 'ph--clock-countdown--regular',
-                  disposition: 'hidden',
-                },
+            }),
+            Node.makeAction({
+              id: AssistantOperation.ToggleTracePanelDebug.meta.key,
+              data: () => Operation.invoke(AssistantOperation.ToggleTracePanelDebug, {}),
+              properties: {
+                label: ['toggle-trace-panel-debug.label', { ns: meta.id }],
+                icon: 'ph--brackets-curly--regular',
               },
-            ]),
-            Option.getOrElse(() => []),
-          ),
+            }),
+          ]),
+      }),
+
+      // Don't show assistant companion when a chat is already the primary object.
+      GraphBuilder.createExtension({
+        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 objectUri = Obj.getURI(object);
+
+            // Resolve chat from persisted state or transient cache.
+            const chat = pipe(
+              Option.fromNullable(state.currentChat[objectUri]),
+              Option.flatMap((dxnStr) => Option.fromNullable(DXN.tryMake(dxnStr))),
+              Option.flatMap((dxn) => Option.fromNullable(Obj.getDatabase(object)?.makeRef(dxn))),
+              Option.map((ref) => get(Obj.atom(ref as Ref.Ref<Obj.Unknown>))),
+              Option.filter(Obj.isObject),
+              Option.orElse(() => pipe(Option.fromNullable(cache[objectUri]), Option.filter(Obj.isObject))),
+              Option.getOrNull,
+            );
+
+            return [
+              AppNode.makeCompanion({
+                id: linkedSegment(ASSISTANT_COMPANION_VARIANT),
+                label: ['assistant-chat.label', { ns: meta.id }],
+                icon: 'ph--sparkle--regular',
+                data: chat,
+                position: 'first',
+              }),
+            ];
+          }),
+      }),
+
+      GraphBuilder.createExtension({
+        id: 'invocations',
+        match: NodeMatcher.whenAny(
+          NodeMatcher.whenEchoTypeMatches(Sequence.Sequence),
+          NodeMatcher.whenEchoTypeMatches(Routine.Routine),
+        ),
+        connector: () =>
+          Effect.succeed([
+            AppNode.makeCompanion({
+              id: 'invocations',
+              label: ['invocations.label', { ns: meta.id }],
+              icon: 'ph--clock-countdown--regular',
+              data: 'invocations',
+            }),
+          ]),
+      }),
+
+      GraphBuilder.createExtension({
+        id: 'trace',
+        match: NodeMatcher.whenRoot,
+        connector: () =>
+          Effect.succeed([
+            AppNode.makeDeckCompanion({
+              id: linkedSegment('trace'),
+              label: ['trace.label', { ns: meta.id }],
+              icon: 'ph--line-segments--regular',
+              data: 'trace' as const,
+              position: 'last',
+            }),
+          ]),
+      }),
+
+      // 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(),
         ),
-    }),
-  ]);
-
-// TODO(burdon): Factor out.
-const getOrCreateChat = async (
-  dispatch: PromiseIntentDispatcher,
-  space: Space,
-): Promise<Assistant.Chat | undefined> => {
-  // TODO(wittjosiah): This should be possible with a single query.
-  const { objects: allChats } = await space.db.query(Query.type(Assistant.Chat)).run();
-  const { objects: relatedChats } = await space.db
-    .query(Query.type(Assistant.Chat).sourceOf(Assistant.CompanionTo).source())
-    .run();
-  const chats = allChats.filter((chat) => !relatedChats.includes(chat));
-  // console.log('objects', JSON.stringify(objects, null, 2));
-  if (chats.length > 0) {
-    // TODO(burdon): Is this the most recent?
-    return chats[chats.length - 1];
-  }
-
-  const { data } = await dispatch(createIntent(AssistantAction.CreateChat, { space }));
-  invariant(Obj.instanceOf(Assistant.Chat, data?.object));
-  await dispatch(createIntent(SpaceAction.AddObject, { target: space, object: data.object }));
-  return data.object;
-};
+      }),
+
+      // 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),
+      Capability.contributes(AppCapabilities.NavigationPathResolver, createTypeSectionPathResolver(Chat.Chat)),
+    ];
+  }),
+);

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

@@ -2,31 +2,64 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ToolId } from '@dxos/ai';
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { templates } from '@dxos/assistant';
-import { Blueprint } from '@dxos/blueprints';
+import * as Effect from 'effect/Effect';
 
-import { analysis, list, load } from '../functions';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import {
+  AgentBlueprint,
+  AgentBlueprintHandlers,
+  AgentHandlers,
+  AgentWizardBlueprint,
+  AgentWizardHandlers,
+  BlueprintManagerBlueprint,
+  BlueprintManagerHandlers,
+  BrowserBlueprint,
+  DatabaseBlueprint,
+  DatabaseHandlers,
+  DiscordBlueprint,
+  LinearBlueprint,
+  PlanningBlueprint,
+  WebSearchBlueprint,
+  WebSearchHandlers,
+  MemoryBlueprint,
+  AutomationBlueprint,
+  DelegationBlueprint,
+  DelegationHandlers,
+  makeDelegationStrategy,
+} from '@dxos/assistant-toolkit';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
 
-const functions = [analysis, list, load];
-const tools: string[] = [
-  'get-schemas',
-  'create-record',
-  // 'open-item'
-];
+import { AssistantBlueprint } from '#blueprints';
 
-export default () => {
-  return [
-    contributes(
-      Capabilities.BlueprintDefinition,
-      Blueprint.make({
-        key: 'dxos.org/blueprint/assistant',
-        name: 'Assistant',
-        instructions: templates.system,
-        tools: [...functions.map((tool) => ToolId.make(tool.name)), ...tools.map((tool) => ToolId.make(tool))],
-      }),
-    ),
-    contributes(Capabilities.Functions, functions),
-  ];
-};
+// 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, WebSearchBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, DiscordBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, LinearBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, AgentBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, PlanningBlueprint),
+    Capability.contributes(AppCapabilities.BlueprintDefinition, MemoryBlueprint),
+    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, 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;