@dxos/plugin-assistant 0.8.4-main.422d1c7879 → 0.8.4-main.43cb759274

package/src/AssistantPlugin.test.ts

@@ -0,0 +1,152 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import { type TestContext } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { AiService } from '@dxos/ai';
+import { TestAiService } from '@dxos/ai/testing';
+import { AppActivationEvents } from '@dxos/app-toolkit';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Operation, Routine, ServiceResolver } from '@dxos/compute';
+import { Database, Feed, Ref } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
+import { TestContextService } from '@dxos/effect/testing';
+import { EntityId } from '@dxos/keys';
+import { AutomationPlugin } from '@dxos/plugin-automation/plugin';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { ClientPlugin } from '@dxos/plugin-client/plugin';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { createComposerTestApp } from '@dxos/plugin-testing/harness';
+
+import { AssistantPlugin } from '#plugin';
+
+import { meta } from './meta';
+
+EntityId.dangerouslyDisableRandomness();
+
+const moduleId = (name: string) => `${meta.id}.module.${name}`;
+
+describe('AssistantPlugin', () => {
+  test('modules activate on the expected events', async ({ expect }) => {
+    await using harness = await createComposerTestApp({
+      plugins: [ClientPlugin({}), AssistantPlugin()],
+    });
+
+    // After autoStart: AppGraphBuilder, CreateObject, schema, OperationHandler all auto-cascade.
+    expect(harness.manager.getActive()).toEqual(
+      expect.arrayContaining([moduleId('AppGraphBuilder'), moduleId('CreateObject'), moduleId('schema')]),
+    );
+
+    // AssistantPlugin fires SetupArtifactDefinition itself, so it can test its own blueprint.
+    await harness.fire(AppActivationEvents.SetupArtifactDefinition);
+    expect(harness.manager.getActive()).toContain(moduleId('BlueprintDefinition'));
+
+    // OperationHandler auto-cascades from ProcessManagerPlugin.
+    expect(harness.manager.getActive()).toContain(moduleId('OperationHandler'));
+
+    // AiService module must activate on SetupProcessManager (before the process manager is built).
+    expect(harness.manager.getActive()).toContain(moduleId('AiService'));
+
+    // AiService must be resolvable via the process manager's ServiceResolver.
+    await harness.runPromise(
+      Effect.gen(function* () {
+        const aiService = yield* AiService.AiService;
+        expect(aiService).toBeDefined();
+      }).pipe(Effect.provide(ServiceResolver.provide({}, AiService.AiService))),
+    );
+  });
+
+  test('can memoize ai-service requests', async (ctx) => {
+    const { expect } = ctx;
+    await using harness = await createComposerTestApp({
+      plugins: [
+        ClientPlugin({}),
+        AssistantPlugin({
+          aiServiceMiddleware: await makeMemoizedAiServiceMiddleware(ctx),
+        }),
+      ],
+    });
+
+    await harness.runPromise(
+      Effect.gen(function* () {
+        const { text } = yield* LanguageModel.generateText({
+          prompt: 'What is the capital of France?',
+        });
+        expect(text.toLocaleLowerCase()).toContain('paris');
+      }).pipe(
+        Effect.provide(
+          AiService.model('@anthropic/claude-haiku-4-5').pipe(
+            Layer.provideMerge(ServiceResolver.provide({}, AiService.AiService)),
+          ),
+        ),
+      ),
+    );
+  });
+
+  test('can run memoized routine', { timeout: 120_000 }, async (ctx) => {
+    const { expect } = ctx;
+    await using harness = await createComposerTestApp({
+      plugins: [
+        ClientPlugin({}),
+        AssistantPlugin({
+          aiServiceMiddleware: await makeMemoizedAiServiceMiddleware(ctx),
+        }),
+        AutomationPlugin(),
+      ],
+    });
+
+    await harness.fire(AppActivationEvents.SetupArtifactDefinition);
+
+    const { personalSpace } = await runAndForwardErrors(initializeIdentity(harness.get(ClientCapabilities.Client)));
+
+    await harness.runPromise(
+      Effect.gen(function* () {
+        const routine = yield* Database.add(
+          Routine.make({
+            name: 'capital-test',
+            instructions:
+              'Call completeJob with success set to a JSON object { "capital": "<lowercase country capital>" } for the country in input.',
+            input: Schema.Struct({
+              country: Schema.String,
+            }),
+            output: Schema.Struct({
+              capital: Schema.String,
+            }),
+          }),
+        );
+        yield* Database.flush();
+
+        const result = yield* Operation.invoke(
+          AgentPrompt,
+          {
+            prompt: Ref.make(routine),
+            input: {
+              country: 'France',
+            },
+            model: '@anthropic/claude-haiku-4-5',
+          },
+          { spaceId: personalSpace.id },
+        );
+        expect(result).toEqual({ capital: 'paris' });
+      }).pipe(Effect.provide(ServiceResolver.provide({ space: personalSpace.id }, Database.Service, Feed.FeedService))),
+    );
+  });
+});
+
+const makeMemoizedAiServiceMiddleware = (
+  ctx: TestContext,
+): Promise<(_upstream: AiService.Service) => AiService.Service> =>
+  AiService.AiService.pipe(
+    Effect.provide(
+      TestAiService({ preset: 'direct' }).pipe(Layer.provideMerge(Layer.succeed(TestContextService, ctx))),
+    ),
+    // Ignoring actual AI service the plugin contructs and using our own.
+    Effect.map((service) => (_upstream: AiService.Service) => service),
+    Effect.runPromise,
+  );

package/src/AssistantPlugin.ts

@@ -0,0 +1,147 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { ActivationEvent, ActivationEvents, Capability, Plugin } from '@dxos/app-framework';
+import { AppActivationEvents, AppPlugin } from '@dxos/app-toolkit';
+import { AiContext } from '@dxos/assistant';
+import { Agent, Chat, McpServer, Memory, Plan } from '@dxos/assistant-toolkit';
+import { Blueprint, Operation, Routine } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { Feed } from '@dxos/echo';
+import { ClientEvents } from '@dxos/plugin-client';
+import { DeckEvents } from '@dxos/plugin-deck';
+import { MarkdownEvents } from '@dxos/plugin-markdown';
+import { SpaceCapabilities, SpaceEvents } from '@dxos/plugin-space';
+import { Text } from '@dxos/schema';
+import { HasSubject, Message } from '@dxos/types';
+
+import {
+  AiContext as AiContextCapability,
+  AiService,
+  AppGraphBuilder,
+  AssistantState,
+  BlueprintDefinition,
+  CompanionChatProvisioner,
+  CreateObject,
+  EdgeModelResolver,
+  LocalModelResolver,
+  MarkdownExtension,
+  Migrations,
+  OperationHandler,
+  ReactSurface,
+  Settings,
+  Toolkit,
+} from '#capabilities';
+import { meta } from '#meta';
+import { translations } from '#translations';
+import { AssistantEvents, AssistantOperation, type AssistantPluginOptions } from '#types';
+
+// eslint-disable-next-line import/no-relative-packages
+import pluginSpec from '../PLUGIN.mdl?raw';
+
+const StateReady = AppActivationEvents.createStateEvent(meta.id);
+
+export const AssistantPlugin = Plugin.define<AssistantPluginOptions | void>(meta).pipe(
+  AppPlugin.addAppGraphModule({ activate: AppGraphBuilder }),
+  AppPlugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),
+  AppPlugin.addCreateObjectModule({ activate: CreateObject }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      Chat.Chat,
+      Chat.CompanionTo,
+      Blueprint.Blueprint,
+      AiContext.Binding,
+      Feed.Feed,
+      HasSubject.HasSubject,
+      Message.Message,
+      Routine.Routine,
+      Agent.Agent,
+      McpServer.McpServer,
+      Plan.Plan,
+      Sequence.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,
+    firesAfterActivation: [StateReady],
+    activate: AssistantState,
+  }),
+  Plugin.addModule({
+    id: 'on-space-created',
+    activatesOn: SpaceEvents.SpaceCreated,
+    activate: () =>
+      Effect.succeed(
+        Capability.contributes(SpaceCapabilities.OnCreateSpace, (params) =>
+          Operation.invoke(AssistantOperation.OnCreateSpace, params),
+        ),
+      ),
+  }),
+  Plugin.addModule({
+    activatesOn: AssistantEvents.SetupAiServiceProviders,
+    activate: EdgeModelResolver,
+  }),
+  Plugin.addModule({
+    activatesOn: AssistantEvents.SetupAiServiceProviders,
+    activate: LocalModelResolver,
+  }),
+  Plugin.addModule((options) => ({
+    id: Capability.getModuleTag(AiService),
+    firesBeforeActivation: [AssistantEvents.SetupAiServiceProviders],
+    // TODO(dmaretskyi): This should activate lazily when the AI chat is used.
+    activatesOn: ActivationEvents.SetupProcessManager,
+    activate: () => AiService(options),
+  })),
+  Plugin.addModule({
+    // Process-affinity `AiContext.Service` LayerSpec — needed so operations
+    // dispatched as their own processes (e.g. via `Operation.invoke` from
+    // `AiSession.createRequest` or `TriggerDispatcher`) can resolve
+    // conversation-scoped services without an inline `Effect.provideService`
+    // upstream. See `capabilities/ai-context.ts` for the rationale.
+    activatesOn: ActivationEvents.SetupProcessManager,
+    activate: AiContextCapability,
+  }),
+  Plugin.addModule({
+    // TODO(wittjosiah): Use a different event.
+    activatesOn: ActivationEvents.Startup,
+    activate: Toolkit,
+  }),
+  Plugin.addModule({
+    activatesOn: ActivationEvent.allOf(
+      ActivationEvents.ProcessManagerReady,
+      AppActivationEvents.AppGraphReady,
+      DeckEvents.StateReady,
+      StateReady,
+    ),
+    activate: CompanionChatProvisioner,
+  }),
+  Plugin.addModule({
+    activatesOn: ClientEvents.SetupMigration,
+    activate: Migrations,
+  }),
+  AppPlugin.addPluginAssetModule({
+    asset: { pluginId: meta.id, path: 'PLUGIN.mdl', content: pluginSpec, mimeType: 'application/x-mdl' },
+  }),
+  Plugin.make,
+);
+
+export default AssistantPlugin;

package/src/AssistantPlugin.workerd.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { AiContext } from '@dxos/assistant';
+import { Agent, Chat, McpServer, Memory, Plan } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine } from '@dxos/compute';
+import { Sequence } from '@dxos/conductor';
+import { Feed } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { HasSubject, Message } from '@dxos/types';
+
+import { OperationHandler } from '#capabilities';
+import { meta } from '#meta';
+
+export const AssistantPlugin = Plugin.define(meta).pipe(
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      Chat.Chat,
+      Chat.CompanionTo,
+      Blueprint.Blueprint,
+      AiContext.Binding,
+      Feed.Feed,
+      HasSubject.HasSubject,
+      Message.Message,
+      Routine.Routine,
+      Agent.Agent,
+      McpServer.McpServer,
+      Plan.Plan,
+      Sequence.Sequence,
+      Memory.Memory,
+      Text.Text,
+    ],
+  }),
+  Plugin.make,
+);
+
+export default AssistantPlugin;

package/src/blueprints/assistant/{blueprint.test.ts → blueprint.node.test.ts}

@@ -5,18 +5,18 @@
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 
-import { AgentService } from '@dxos/assistant';
 import { DatabaseBlueprint, DatabaseHandlers } from '@dxos/assistant-toolkit';
-import { AssistantTestLayer } from '@dxos/assistant/testing';
-import { Blueprint } from '@dxos/blueprints';
+import { Blueprint } from '@dxos/compute';
 import { Feed } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { ObjectId } from '@dxos/keys';
+import { AgentService } from '@dxos/functions-runtime';
+import { AssistantTestLayer } from '@dxos/functions-runtime/testing';
+import { EntityId } from '@dxos/keys';
 import { Organization } from '@dxos/types';
 
 import AssistantBlueprint from './blueprint';
 
-ObjectId.dangerouslyDisableRandomness();
+EntityId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayer({
   aiServicePreset: 'edge-remote',

package/src/blueprints/assistant/blueprint.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { LayoutOperation, type AppCapabilities } from '@dxos/app-toolkit';
+import { LayoutOperation } from '@dxos/app-toolkit';
 import { templates } from '@dxos/assistant';
-import { Blueprint } from '@dxos/blueprints';
+import { Blueprint } from '@dxos/compute';
 
-import { AssistantOperation } from '#operations';
+import { AssistantOperation } from '#types';
 
 const BLUEPRINT_KEY = 'org.dxos.blueprint.assistant';
 
@@ -23,7 +23,7 @@ const make = () =>
     instructions: templates.system,
   });
 
-const blueprint: AppCapabilities.BlueprintDefinition = {
+const blueprint: Blueprint.Definition = {
   key: BLUEPRINT_KEY,
   make,
 };

package/src/capabilities/ai-context.ts

@@ -0,0 +1,85 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AiContext } from '@dxos/assistant';
+import { LayerSpec, ServiceNotAvailableError } from '@dxos/compute';
+import { Database, EID, Feed } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+
+//
+// Capability Module
+//
+// Contributes a process-affinity `LayerSpec` that materialises
+// {@link AiContext.Service} from the resolution context's `conversation` DXN.
+//
+// Previously, `AiContext.Service` was provided only inline by the assistant
+// plugin processor and by `AiSession.createRequest`. That works while the
+// formatting code runs inside the calling fiber, but breaks the moment any
+// nested call crosses a process boundary via `Operation.invoke` — the spawned
+// process gets its own `ServiceResolver`/`LayerStack` and there is no
+// production provider for `AiContext.Service` to back it.
+//
+// The dispatcher path (trigger → AgentWorker → AiSession.createRequest →
+// formatSystemPrompt → Template.processTemplate → Operation.invoke(GetContext))
+// hits exactly this gap: `GetContext` declares `services: [AiContext.Service,
+// Database.Service]`, the child spawn inherits `space` + `conversation` from
+// the parent's environment (see TriggerDispatcher + Operation.invoke), but
+// then `LayerStack` has nothing to satisfy `AiContext.Service` with.
+//
+// This spec mirrors the test-layer factory in
+// `@dxos/functions-runtime/testing` so the production resolver behaves the
+// same way: load the conversation feed via `Database.Service`, hand it to an
+// `AiContext.Binder`, and scope the binder to the process slice's lifetime.
+//
+
+/**
+ * Process-affinity LayerSpec for {@link AiContext.Service}.
+ *
+ * The factory runs once per process slice (keyed on space + conversation +
+ * process id). If `context.conversation` is absent the slice fails with a
+ * `ServiceNotAvailable` defect — there is no useful binder to build without
+ * a conversation feed, and a precise error at slice init beats a silent
+ * binder that throws on first use.
+ */
+const AiContextSpec = LayerSpec.make(
+  {
+    affinity: 'process',
+    requires: [Database.Service, Feed.FeedService],
+    provides: [AiContext.Service],
+  },
+  (context) =>
+    Layer.scoped(
+      AiContext.Service,
+      Effect.gen(function* () {
+        // The spec is registered unconditionally so the LayerStack knows how
+        // to satisfy `AiContext.Service` in principle. Surface a precise
+        // failure when the conversation context is missing — this happens
+        // when an operation that requires `AiContext.Service` is invoked
+        // without going through `Operation.withInvocationOptions({
+        // conversation })` (or equivalent spawn `environment`). Raised as a
+        // defect because the spec's factory must produce
+        // `Layer<..., never, ...>`; the trigger dispatcher's `causeToError`
+        // path still surfaces the original message in logs.
+        if (!context.conversation) {
+          return yield* Effect.die(
+            new ServiceNotAvailableError(AiContext.Service.key, {
+              message: `Service not available: ${AiContext.Service.key} — process spawn is missing 'conversation' in environment (set via Operation.withInvocationOptions or ProcessManager.spawn environment)`,
+            }),
+          );
+        }
+        const feed = yield* Database.resolve(EID.parse(context.conversation), Feed.Feed).pipe(Effect.orDie);
+        const runtime = yield* Effect.runtime<Feed.FeedService>();
+        const binder = yield* acquireReleaseResource(() => new AiContext.Binder({ feed, runtime }));
+        return { binder };
+      }),
+    ),
+);
+
+export default Capability.makeModule(() =>
+  Effect.succeed([Capability.contributes(Capabilities.LayerSpec, AiContextSpec)]),
+);

package/src/capabilities/ai-service.ts

@@ -2,15 +2,19 @@
 // Copyright 2023 DXOS.org
 //
 
+import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { AiModelResolver } from '@dxos/ai';
-import { Capability } from '@dxos/app-framework';
+import { AiModelResolver, AiService } from '@dxos/ai';
+import { Capabilities, Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
+import { LayerSpec } from '@dxos/compute';
 
-export default Capability.makeModule(
-  Effect.fnUntraced(function* () {
+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.
@@ -19,12 +23,35 @@ export default Capability.makeModule(
       AiModelResolver.AiModelResolver.fromModelMap({ name: 'Fallback' }, Effect.succeed({})), // Empty resolver as fallback.
     );
 
+    let aiServiceLayer: Layer.Layer<AiService.AiService> = 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: 'application',
+        requires: [],
+        provides: [AiService.AiService],
+      },
+      () => aiServiceLayer,
+    );
+
     return [
-      // TODO(dmaretskyi): Read config from settings.
-      Capability.contributes(
-        AppCapabilities.AiServiceLayer,
-        AiModelResolver.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer)),
-      ),
+      // Deprecated: `AppCapabilities.AiServiceLayer` is retained for non-process-manager
+      // call sites (e.g. legacy CLI paths). New consumers should resolve `AiService.AiService`
+      // through the process manager runtime via the `LayerSpec` contribution below.
+      Capability.contributes(AppCapabilities.AiServiceLayer, aiServiceLayer),
+      Capability.contributes(Capabilities.LayerSpec, aiServiceSpec),
     ];
   }),
 );