@dxos/plugin-assistant 0.8.4-main.c4373fc → 0.8.4-main.d9fc60f731

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.node.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 { EntityId } from '@dxos/keys';
+import { Organization } from '@dxos/types';
+
+import AssistantBlueprint from './blueprint';
+
+EntityId.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 '#types';
+
+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/Toolbar → blueprints}/index.ts

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

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,26 +2,56 @@
 // Copyright 2023 DXOS.org
 //
 
+import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
-
-export default (context: PluginContext) => {
-  const resolvers = context.getCapabilities(Capabilities.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(
-      Capabilities.AiServiceLayer,
-      AiServiceRouter.AiModelResolver.buildAiService.pipe(Layer.provide(combinedLayer)),
-    ),
-  ];
-};
+import { AiModelResolver, AiService } from '@dxos/ai';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { 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> = 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 [
+      // 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),
+    ];
+  }),
+);