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

package/src/AssistantPlugin.tsx

@@ -2,144 +2,235 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Capabilities, Events, contributes, createIntent, defineModule, definePlugin } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/blueprints';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { ActivationEvent, ActivationEvents, Capability, Plugin } from '@dxos/app-framework';
+import { AppActivationEvents, AppPlugin } from '@dxos/app-toolkit';
+import { ContextBinding } from '@dxos/assistant';
+import { Agent, AgentBlueprint, Chat, McpServer, Memory, Plan } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
 import { Sequence } from '@dxos/conductor';
-import { Type } from '@dxos/echo';
-import { ClientCapabilities, ClientEvents } from '@dxos/plugin-client';
-import { SpaceCapabilities, SpaceEvents } from '@dxos/plugin-space';
-import { defineObjectForm } from '@dxos/plugin-space/types';
+import { Annotation, Feed, Obj, Type } from '@dxos/echo';
+import { type SpaceId } from '@dxos/keys';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { ClientEvents } from '@dxos/plugin-client/types';
+import { DeckEvents } from '@dxos/plugin-deck/types';
+import { MarkdownEvents } from '@dxos/plugin-markdown/types';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
+import { type CreateObject, SpaceCapabilities, SpaceEvents } from '@dxos/plugin-space/types';
+import { Text } from '@dxos/schema';
+import { HasSubject, Message } from '@dxos/types';
 
 import {
   AiService,
   AppGraphBuilder,
+  AssistantState,
   BlueprintDefinition,
+  CompanionChatProvisioner,
   EdgeModelResolver,
-  IntentResolver,
+  LocalModelResolver,
+  MarkdownExtension,
+  Migrations,
+  OperationHandler,
   ReactSurface,
   Settings,
   Toolkit,
-} from './capabilities';
-import { AssistantEvents } from './events';
-import { meta } from './meta';
-import { translations } from './translations';
-import { Assistant, AssistantAction, ServiceType } from './types';
+} from '#capabilities';
+import { meta } from '#meta';
+import { AssistantOperation } from '#operations';
+import { translations } from '#translations';
+import { AssistantEvents } from '#types';
 
-export const AssistantPlugin = () =>
-  definePlugin(meta, [
-    defineModule({
-      id: `${meta.id}/module/translations`,
-      activatesOn: Events.SetupTranslations,
-      activate: () => contributes(Capabilities.Translations, translations),
-    }),
-    defineModule({
-      id: `${meta.id}/module/settings`,
-      activatesOn: Events.SetupSettings,
-      activate: Settings,
-    }),
-    defineModule({
-      id: `${meta.id}/module/metadata`,
-      activatesOn: Events.SetupMetadata,
-      activate: () => [
-        contributes(Capabilities.Metadata, {
-          id: Type.getTypename(Assistant.Chat),
-          metadata: {
-            icon: 'ph--atom--regular',
-          },
-        }),
-        contributes(Capabilities.Metadata, {
-          id: Type.getTypename(Blueprint.Blueprint),
-          metadata: {
-            icon: 'ph--blueprint--regular',
-          },
-        }),
-        contributes(Capabilities.Metadata, {
-          id: Type.getTypename(Sequence),
-          metadata: {
-            icon: 'ph--circuitry--regular',
-          },
-        }),
-      ],
-    }),
-    defineModule({
-      id: `${meta.id}/module/object-form`,
-      activatesOn: ClientEvents.SetupSchema,
-      activate: () => [
-        contributes(
-          SpaceCapabilities.ObjectForm,
-          defineObjectForm({
-            objectSchema: Assistant.Chat,
-            getIntent: (_, options) => createIntent(AssistantAction.CreateChat, { space: options.space }),
-          }),
-        ),
-        contributes(
-          SpaceCapabilities.ObjectForm,
-          defineObjectForm({
-            objectSchema: Blueprint.Blueprint,
-            formSchema: AssistantAction.BlueprintForm,
-            getIntent: (props) => createIntent(AssistantAction.CreateBlueprint, props),
-          }),
-        ),
-        contributes(
-          SpaceCapabilities.ObjectForm,
-          defineObjectForm({
-            objectSchema: Sequence,
-            getIntent: () => createIntent(AssistantAction.CreateSequence),
-          }),
+export const AssistantPlugin = Plugin.define(meta).pipe(
+  AppPlugin.addAppGraphModule({ activate: AppGraphBuilder }),
+  AppPlugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),
+  AppPlugin.addMetadataModule({
+    metadata: [
+      {
+        id: Type.getTypename(Chat.Chat),
+        metadata: {
+          icon: Annotation.IconAnnotation.get(Chat.Chat).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Chat.Chat).pipe(Option.getOrThrow).hue ?? 'white',
+          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,
+              });
+            })) satisfies CreateObject,
+        },
+      },
+      {
+        id: Type.getTypename(Blueprint.Blueprint),
+        metadata: {
+          icon: Annotation.IconAnnotation.get(Blueprint.Blueprint).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Blueprint.Blueprint).pipe(Option.getOrThrow).hue ?? 'white',
+          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,
+              });
+            })) satisfies CreateObject,
+        },
+      },
+      {
+        id: Type.getTypename(Routine.Routine),
+        metadata: {
+          icon: Annotation.IconAnnotation.get(Routine.Routine).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Routine.Routine).pipe(Option.getOrThrow).hue ?? 'white',
+          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,
+              });
+            })) satisfies CreateObject,
+        },
+      },
+      {
+        id: Type.getTypename(Sequence),
+        metadata: {
+          icon: Annotation.IconAnnotation.get(Sequence).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Sequence).pipe(Option.getOrThrow).hue ?? 'white',
+          createObject: ((props, options) =>
+            Effect.gen(function* () {
+              const object = Obj.make(Sequence, props);
+              return yield* Operation.invoke(SpaceOperation.AddObject, {
+                object,
+                target: options.target,
+                hidden: true,
+                targetNodeId: options.targetNodeId,
+              });
+            })) satisfies CreateObject,
+        },
+      },
+      {
+        id: Type.getTypename(Agent.Agent),
+        metadata: {
+          icon: Annotation.IconAnnotation.get(Agent.Agent).pipe(Option.getOrThrow).icon,
+          iconHue: Annotation.IconAnnotation.get(Agent.Agent).pipe(Option.getOrThrow).hue ?? 'white',
+          createObject: ((props, options) =>
+            Effect.gen(function* () {
+              const object = yield* Agent.makeInitialized({ name: '', instructions: '' }, AgentBlueprint.make()).pipe(
+                withComputeRuntime(options.db.spaceId),
+              );
+              return yield* Operation.invoke(SpaceOperation.AddObject, {
+                object,
+                target: options.target,
+                hidden: true,
+                targetNodeId: options.targetNodeId,
+              });
+            })) satisfies CreateObject,
+        },
+      },
+    ],
+  }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      Chat.Chat,
+      Chat.CompanionTo,
+      Blueprint.Blueprint,
+      ContextBinding,
+      Feed.Feed,
+      HasSubject.HasSubject,
+      Message.Message,
+      Routine.Routine,
+      Agent.Agent,
+      McpServer.McpServer,
+      Plan.Plan,
+      Sequence,
+      Memory.Memory,
+      Text.Text,
+    ],
+  }),
+  AppPlugin.addSettingsModule({ activate: Settings }),
+  AppPlugin.addSurfaceModule({
+    activate: ReactSurface,
+    firesBeforeActivation: [AppActivationEvents.SetupArtifactDefinition],
+  }),
+  AppPlugin.addTranslationsModule({ translations }),
+  Plugin.addModule({
+    id: 'markdown',
+    activatesOn: MarkdownEvents.SetupExtensions,
+    activate: MarkdownExtension,
+  }),
+  Plugin.addModule({
+    // TODO(wittjosiah): Does not integrate with settings store.
+    //   Should this be a different event?
+    //   Should settings store be renamed to be more generic?
+    activatesOn: AppActivationEvents.SetupSettings,
+    activate: AssistantState,
+  }),
+  Plugin.addModule({
+    id: 'on-space-created',
+    activatesOn: SpaceEvents.SpaceCreated,
+    activate: () =>
+      Effect.succeed(
+        Capability.contributes(SpaceCapabilities.OnCreateSpace, (params) =>
+          Operation.invoke(AssistantOperation.OnCreateSpace, params),
         ),
-      ],
-    }),
-    defineModule({
-      id: `${meta.id}/module/schema`,
-      activatesOn: ClientEvents.SetupSchema,
-      activate: () => contributes(ClientCapabilities.Schema, [ServiceType, Assistant.CompanionTo]),
-    }),
-    defineModule({
-      id: `${meta.id}/module/on-space-created`,
-      activatesOn: SpaceEvents.SpaceCreated,
-      activate: () =>
-        contributes(SpaceCapabilities.OnSpaceCreated, ({ rootCollection, space }) =>
-          createIntent(AssistantAction.OnSpaceCreated, { rootCollection, space }),
-        ),
-    }),
-    defineModule({
-      id: `${meta.id}/module/app-graph-builder`,
-      activatesOn: Events.SetupAppGraph,
-      activate: AppGraphBuilder,
-    }),
-    defineModule({
-      id: `${meta.id}/module/intent-resolver`,
-      activatesOn: Events.SetupIntentResolver,
-      activate: IntentResolver,
-    }),
-    defineModule({
-      id: `${meta.id}/module/react-surface`,
-      activatesOn: Events.SetupReactSurface,
-      // TODO(wittjosiah): Should occur before the chat is loaded when surfaces activation is more granular.
-      activatesBefore: [Events.SetupArtifactDefinition],
-      activate: ReactSurface,
-    }),
-    defineModule({
-      id: `${meta.id}/module/ai-model-resolver`,
-      activatesOn: AssistantEvents.SetupAiServiceProviders,
-      activate: EdgeModelResolver,
-    }),
-    defineModule({
-      id: `${meta.id}/module/ai-service`,
-      activatesBefore: [AssistantEvents.SetupAiServiceProviders],
-      // TODO(dmaretskyi): This should activate lazily when the AI chat is used.
-      activatesOn: Events.Startup,
-      activate: AiService,
-    }),
-    defineModule({
-      id: `${meta.id}/module/blueprint`,
-      activatesOn: Events.SetupArtifactDefinition,
-      activate: BlueprintDefinition,
-    }),
-    defineModule({
-      id: `${meta.id}/module/toolkit`,
-      // TODO(wittjosiah): Use a different event.
-      activatesOn: Events.Startup,
-      activate: Toolkit,
-    }),
-  ]);
+      ),
+  }),
+  Plugin.addModule({
+    activatesOn: AssistantEvents.SetupAiServiceProviders,
+    activate: EdgeModelResolver,
+  }),
+  Plugin.addModule({
+    activatesOn: AssistantEvents.SetupAiServiceProviders,
+    activate: LocalModelResolver,
+  }),
+  Plugin.addModule({
+    firesBeforeActivation: [AssistantEvents.SetupAiServiceProviders],
+    // TODO(dmaretskyi): This should activate lazily when the AI chat is used.
+    activatesOn: ActivationEvents.Startup,
+    activate: AiService,
+  }),
+  Plugin.addModule({
+    // TODO(wittjosiah): Use a different event.
+    activatesOn: ActivationEvents.Startup,
+    activate: Toolkit,
+  }),
+  Plugin.addModule({
+    activatesOn: ActivationEvent.allOf(
+      ActivationEvents.OperationInvokerReady,
+      AppActivationEvents.AppGraphReady,
+      DeckEvents.StateReady,
+    ),
+    activate: CompanionChatProvisioner,
+  }),
+  Plugin.addModule({
+    activatesOn: ClientEvents.SetupMigration,
+    activate: Migrations,
+  }),
+  Plugin.make,
+);
+
+// TODO(dmaretskyi): Extract to a helper module.
+const withComputeRuntime =
+  (spaceId: SpaceId) =>
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, E, Exclude<R, AutomationCapabilities.ComputeServices> | Capability.Service> =>
+    Effect.gen(function* () {
+      // TODO(dmaretskyi): Capability.get has `Error` in the error channel. We should throw those as defects instead.
+      const provider = yield* Capability.get(AutomationCapabilities.ComputeRuntime).pipe(Effect.orDie);
+      const runtime = yield* provider.getRuntime(spaceId).runtimeEffect;
+      return yield* effect.pipe(Effect.provide(runtime));
+    });

package/src/blueprints/assistant/blueprint.test.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { DatabaseBlueprint, DatabaseHandlers } from '@dxos/assistant-toolkit';
+import { Blueprint } from '@dxos/compute';
+import { Feed } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { AgentService } from '@dxos/functions-runtime';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
+import { ObjectId } from '@dxos/keys';
+import { Organization } from '@dxos/types';
+
+import AssistantBlueprint from './blueprint';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  aiServicePreset: 'edge-remote',
+  operationHandlers: DatabaseHandlers,
+  types: [Organization.Organization, Blueprint.Blueprint, Feed.Feed],
+  blueprints: [AssistantBlueprint.make(), DatabaseBlueprint.make()],
+  tracing: 'pretty',
+});
+
+describe('Assistant Blueprint', () => {
+  // TODO(dmaretskyi): Regenerate memoized conversation with ALLOW_LLM_GENERATION=1.
+  it.effect.skip(
+    'works with Database blueprint to create objects',
+    Effect.fnUntraced(
+      function* (_) {
+        const agent = yield* AgentService.createSession({
+          blueprints: [AssistantBlueprint.make(), DatabaseBlueprint.make()],
+        });
+        yield* agent.submitPrompt('Create a new organization called "Test Corp".');
+        yield* agent.waitForCompletion();
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+    { timeout: 60_000 },
+  );
+});

package/src/blueprints/assistant/blueprint.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { templates } from '@dxos/assistant';
+import { Blueprint } from '@dxos/compute';
+
+import { AssistantOperation } from '#operations';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.assistant';
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Assistant',
+    tools: Blueprint.toolDefinitions({
+      // TODO(wittjosiah): LayoutOperation.Open requires Capability.Service which is only available
+      //   via the compute-runtime layer (plugin-automation). Once Capability.Service is propagated
+      //   through LocalFunctionExecutionService, this will work without the compute-runtime dependency.
+      operations: [LayoutOperation.Open, AssistantOperation.ResolveNavigationTargets],
+    }),
+    instructions: templates.system,
+  });
+
+const blueprint: Blueprint.Definition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/assistant/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as AssistantBlueprint } from './blueprint';

package/src/{components/Timeline → blueprints}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './Timeline';
+export * from './assistant';

package/src/capabilities/ai-service.ts

@@ -2,27 +2,29 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Effect, Layer } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
-import { AiServiceRouter } from '@dxos/ai';
-import { type PluginContext, contributes } from '@dxos/app-framework';
+import { AiModelResolver } from '@dxos/ai';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
-import { AssistantCapabilities } from './capabilities';
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const resolvers = yield* Capability.getAll(AppCapabilities.AiModelResolver);
 
-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)),
+      AiModelResolver.AiModelResolver.fromModelMap({ name: 'Fallback' }, Effect.succeed({})), // Empty resolver as fallback.
+    );
 
-  // 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)),
-    ),
-  ];
-};
+    return [
+      // TODO(dmaretskyi): Read config from settings.
+      Capability.contributes(
+        AppCapabilities.AiServiceLayer,
+        AiModelResolver.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer)),
+      ),
+    ];
+  }),
+);