@dxos/plugin-assistant 0.8.4-main.c1de068 → 0.8.4-main.e098934

package/src/capabilities/blueprint-definition.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
+import { templates } from '@dxos/assistant';
+import {
+  DISCORD_BLUEPRINT,
+  LINEAR_BLUEPRINT,
+  RESEARCH_BLUEPRINT,
+  fetchDiscordMessages,
+  research,
+  syncLinearIssues,
+} from '@dxos/assistant-testing';
+import { Blueprint } from '@dxos/blueprints';
+import { type FunctionDefinition } from '@dxos/functions';
+
+import { analysis, list, load } from '../functions';
+
+const functions: FunctionDefinition[] = [analysis, list, load];
+const tools = [
+  'add-to-context',
+  // TODO(wittjosiah): Factor out to an ECHO blueprint.
+  'get-schemas',
+  'add-schema',
+  'create-record',
+  // TODO(wittjosiah): Factor out to a generic app-framework blueprint.
+  'open-item',
+  // TODO(burdon): Anthropic only.
+  //  https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/text-editor-tool#example-str-replace-command
+  //  AI_TOOL_NOT_FOUND: str_replace_based_edit_tool
+  // 'str_replace_based_edit_tool',
+];
+
+export const BLUEPRINT_KEY = 'dxos.org/blueprint/assistant';
+
+export const createBlueprint = (): Blueprint.Blueprint =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Assistant',
+    tools: Blueprint.toolDefinitions({ functions, tools }),
+    instructions: templates.system,
+  });
+
+const blueprint = createBlueprint();
+
+// TODO(dmaretskyi): Consider splitting into multiple modules.
+export default (): Capability<any>[] => [
+  contributes(Capabilities.Functions, functions),
+  contributes(Capabilities.Functions, [research]),
+  contributes(Capabilities.BlueprintDefinition, blueprint),
+  contributes(Capabilities.BlueprintDefinition, RESEARCH_BLUEPRINT),
+  // TODO(burdon): Move out of assistant.
+  contributes(Capabilities.Functions, [syncLinearIssues]),
+  contributes(Capabilities.Functions, [fetchDiscordMessages]),
+  contributes(Capabilities.BlueprintDefinition, LINEAR_BLUEPRINT),
+  contributes(Capabilities.BlueprintDefinition, DISCORD_BLUEPRINT),
+];

package/src/capabilities/capabilities.ts

@@ -0,0 +1,71 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Layer, type ManagedRuntime } from 'effect';
+
+import { type AiService, type AiServiceRouter, type ToolExecutionService, type ToolResolverService } from '@dxos/ai';
+import { defineCapability } from '@dxos/app-framework';
+import type {
+  CredentialsService,
+  DatabaseService,
+  FunctionImplementationResolver,
+  InvocationTracer,
+  LocalFunctionExecutionService,
+  QueueService,
+  RemoteFunctionExecutionService,
+  TriggerDispatcher,
+  TriggerStateStore,
+} from '@dxos/functions';
+import type { SpaceId } from '@dxos/keys';
+import { type DeepReadonly } from '@dxos/util';
+
+import { meta } from '../meta';
+import { type Assistant } from '../types';
+
+export namespace AssistantCapabilities {
+  export type AssistantState = {
+    /** Map of primary object fq id to current chat. */
+    currentChat: Record<string, Assistant.Chat>;
+  };
+  export const State = defineCapability<DeepReadonly<AssistantState>>(`${meta.id}/capability/state`);
+  export const MutableState = defineCapability<AssistantState>(`${meta.id}/capability/state`);
+
+  export type AiServiceLayer = Layer.Layer<AiService.AiService>;
+  export const AiServiceLayer = defineCapability<AiServiceLayer>(`${meta.id}/capability/ai-service-factory`);
+
+  /**
+   * Plugins can contribute them to provide model resolvers.
+   */
+  export const AiModelResolver = defineCapability<Layer.Layer<AiServiceRouter.AiModelResolver>>(
+    `${meta.id}/capability/ai-model-resolver`,
+  );
+
+  /**
+   * Service stack for executing agents, functions, and triggers.
+   */
+  export type ComputeServices =
+    | TriggerDispatcher
+    | AiService.AiService
+    | DatabaseService
+    | QueueService
+    | CredentialsService
+    | LocalFunctionExecutionService
+    | RemoteFunctionExecutionService
+    // TODO(dmaretskyi): This service is private and shouldn't be exposed as a part of public API.
+    | FunctionImplementationResolver
+    | InvocationTracer
+    | TriggerStateStore
+    // TODO(dmaretskyi): Those should be provided at AI-chat call site.
+    | ToolResolverService
+    | ToolExecutionService;
+
+  export interface ComputeRuntimeProvider {
+    getRuntime(spaceId: SpaceId): ManagedRuntime.ManagedRuntime<ComputeServices, never>;
+  }
+
+  /**
+   * Runtime for executing agents, functions, and triggers.
+   */
+  export const ComputeRuntime = defineCapability<ComputeRuntimeProvider>(`${meta.id}/capability/compute-runtime`);
+}

package/src/capabilities/compute-runtime.ts

@@ -0,0 +1,124 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AiTool, AiToolkit } from '@effect/ai';
+import { BrowserKeyValueStore } from '@effect/platform-browser';
+import { Effect, Layer, ManagedRuntime } from 'effect';
+
+import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
+import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
+import { PropertiesType } from '@dxos/client/echo';
+import { Resource } from '@dxos/context';
+import { Query, Ref } from '@dxos/echo';
+import {
+  CredentialsService,
+  DatabaseService,
+  FunctionImplementationResolver,
+  InvocationTracer,
+  LocalFunctionExecutionService,
+  QueueService,
+  RemoteFunctionExecutionService,
+  TriggerDispatcher,
+} from '@dxos/functions';
+import { TriggerStateStore } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { type SpaceId } from '@dxos/keys';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { AssistantCapabilities } from './capabilities';
+
+export default async (context: PluginContext) => {
+  const provider = await new ComputeRuntimeProviderImpl(context).open();
+  return contributes(AssistantCapabilities.ComputeRuntime, provider, async () => {
+    await provider.close();
+  });
+};
+
+class ComputeRuntimeProviderImpl extends Resource implements AssistantCapabilities.ComputeRuntimeProvider {
+  readonly #runtimes = new Map<SpaceId, ManagedRuntime.ManagedRuntime<AssistantCapabilities.ComputeServices, never>>();
+  readonly #context: PluginContext;
+
+  constructor(context: PluginContext) {
+    super();
+    this.#context = context;
+  }
+
+  protected override async _open() {}
+
+  protected override async _close() {
+    await Promise.all(Array.from(this.#runtimes.values()).map((rt) => rt.dispose()));
+    this.#runtimes.clear();
+  }
+
+  getRuntime(spaceId: SpaceId): ManagedRuntime.ManagedRuntime<AssistantCapabilities.ComputeServices, never> {
+    if (this.#runtimes.has(spaceId)) {
+      return this.#runtimes.get(spaceId)!;
+    }
+
+    const layer = Layer.unwrapEffect(
+      Effect.gen(this, function* () {
+        const client = this.#context.getCapability(ClientCapabilities.Client);
+        const serviceLayer =
+          this.#context.getCapability(AssistantCapabilities.AiServiceLayer) ?? Layer.die('AiService not found');
+
+        // TODO(dmaretskyi): Make those reactive.
+        const functions = this.#context.getCapabilities(Capabilities.Functions);
+        const toolkits = this.#context.getCapabilities(Capabilities.Toolkit);
+        const handlers = this.#context.getCapabilities(Capabilities.ToolkitHandler);
+
+        const allFunctions = functions.flat();
+        // TODO(wittjosiah): Don't cast.
+        const toolkit = AiToolkit.merge(...toolkits) as AiToolkit.Any as AiToolkit.AiToolkit<AiTool.Any>;
+        const handlersLayer = Layer.mergeAll(Layer.empty, ...handlers);
+
+        const space = client.spaces.get(spaceId);
+        invariant(space);
+        yield* Effect.promise(() => space.waitUntilReady());
+
+        return Layer.mergeAll(TriggerDispatcher.layer({ timeControl: 'natural' })).pipe(
+          Layer.provideMerge(
+            Layer.mergeAll(
+              IvocationTracerLive,
+              TriggerStateStore.layerKv.pipe(Layer.provide(BrowserKeyValueStore.layerLocalStorage)),
+              serviceLayer,
+              makeToolResolverFromFunctions(allFunctions, toolkit),
+              makeToolExecutionServiceFromFunctions(allFunctions, toolkit, handlersLayer),
+              CredentialsService.layerFromDatabase(),
+            ),
+          ),
+          Layer.provideMerge(
+            Layer.mergeAll(
+              space ? DatabaseService.layer(space.db) : DatabaseService.notAvailable,
+              space ? QueueService.layer(space.queues) : QueueService.notAvailable,
+              LocalFunctionExecutionService.layerLive,
+              RemoteFunctionExecutionService.mockLayer,
+            ),
+          ),
+          Layer.provideMerge(FunctionImplementationResolver.layerTest({ functions: allFunctions })),
+        );
+      }),
+    );
+
+    const runtime = ManagedRuntime.make(layer);
+    this.#runtimes.set(spaceId, runtime);
+
+    return runtime;
+  }
+}
+
+const IvocationTracerLive = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const {
+      objects: [properties],
+    } = yield* DatabaseService.runQuery(Query.type(PropertiesType));
+    invariant(properties);
+    if (!properties.invocationTraceQueue) {
+      const queue = yield* QueueService.createQueue({ subspaceTag: 'trace' });
+      properties.invocationTraceQueue = Ref.fromDXN(queue.dxn);
+    }
+    const queue = properties.invocationTraceQueue.target;
+    invariant(queue);
+    return InvocationTracer.layerLive({ invocationTraceQueue: queue });
+  }),
+);

package/src/capabilities/edge-model-resolver.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
+import { FetchHttpClient } from '@effect/platform';
+import { Layer } from 'effect';
+
+import { AiServiceRouter } from '@dxos/ai';
+import { type Capability, contributes } from '@dxos/app-framework';
+
+import { AssistantCapabilities } from './capabilities';
+
+export default (): Capability<any>[] => [
+  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),
+    ),
+  ),
+];

package/src/capabilities/index.ts

@@ -4,7 +4,17 @@
 
 import { lazy } from '@dxos/app-framework';
 
+export const AiService = lazy(() => import('./ai-service'));
 export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
+export const AssistantState = lazy(() => import('./state'));
+export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
+export const EdgeModelResolver = lazy(() => import('./edge-model-resolver'));
 export const IntentResolver = lazy(() => import('./intent-resolver'));
+export const LocalModelResolver = lazy(() => import('./local-model-resolver'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const Settings = lazy(() => import('./settings'));
+export const Toolkit = lazy(() => import('./toolkit'));
+export const ComputeRuntime = lazy(() => import('./compute-runtime'));
+
+export * from './blueprint-definition';
+export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -4,42 +4,70 @@
 
 import { Effect } from 'effect';
 
-import { Capabilities, contributes, createIntent, createResolver, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
+import { AiContextBinder } from '@dxos/assistant';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { fullyQualifiedId } from '@dxos/client/echo';
 import { Sequence } from '@dxos/conductor';
-import { Key, Obj, Ref } from '@dxos/echo';
+import { Filter, Key, Obj, Ref } from '@dxos/echo';
 import { CollectionAction } from '@dxos/plugin-space/types';
 
-import { Assistant } from '../types';
+import { Assistant, AssistantAction } from '../types';
+
+import { BLUEPRINT_KEY, createBlueprint } from './blueprint-definition';
+import { AssistantCapabilities } from './capabilities';
 
 export default (context: PluginContext) => [
   contributes(Capabilities.IntentResolver, [
     createResolver({
-      intent: Assistant.OnSpaceCreated,
+      intent: AssistantAction.OnSpaceCreated,
       resolve: ({ space, rootCollection }) =>
         Effect.gen(function* () {
           const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const { object: collection } = yield* dispatch(
+          const { object: chatCollection } = yield* dispatch(
             createIntent(CollectionAction.CreateQueryCollection, { typename: Assistant.Chat.typename }),
           );
-          rootCollection.objects.push(Ref.make(collection));
+          const { object: blueprintCollection } = yield* dispatch(
+            createIntent(CollectionAction.CreateQueryCollection, { typename: Blueprint.Blueprint.typename }),
+          );
+          rootCollection.objects.push(Ref.make(chatCollection), Ref.make(blueprintCollection));
 
-          const { object: chat } = yield* dispatch(createIntent(Assistant.CreateChat, { space }));
+          // Create default chat.
+          const { object: chat } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
           space.db.add(chat);
         }),
     }),
     createResolver({
-      intent: Assistant.CreateChat,
-      resolve: ({ space, name }) => ({
+      intent: AssistantAction.CreateChat,
+      resolve: async ({ space, name }) => {
+        const queue = space.queues.create();
+        const chat = Obj.make(Assistant.Chat, { name, queue: Ref.fromDXN(queue.dxn) });
+        const { objects: blueprints } = await space.db.query(Filter.type(Blueprint.Blueprint)).run();
+        // TODO(wittjosiah): This should be a space-level setting.
+        // TODO(burdon): Clone when activated. Copy-on-write for template.
+        let defaultBlueprint = blueprints.find((blueprint) => blueprint.key === BLUEPRINT_KEY);
+        if (!defaultBlueprint) {
+          defaultBlueprint = space.db.add(createBlueprint());
+        }
+
+        const binder = new AiContextBinder(queue);
+        await binder.bind({ blueprints: [Ref.make(defaultBlueprint)] });
+
+        return {
+          data: { object: chat },
+        };
+      },
+    }),
+    createResolver({
+      intent: AssistantAction.CreateBlueprint,
+      resolve: ({ key, name, description }) => ({
         data: {
-          object: Obj.make(Assistant.Chat, {
-            name,
-            queue: Ref.fromDXN(space.queues.create().dxn),
-          }),
+          object: Blueprint.make({ key, name, description, instructions: Template.make({ source: '' }) }),
         },
       }),
     }),
     createResolver({
-      intent: Assistant.CreateSequence,
+      intent: AssistantAction.CreateSequence,
       resolve: ({ name }) => ({
         data: {
           object: Obj.make(Sequence, {
@@ -54,5 +82,13 @@ export default (context: PluginContext) => [
         },
       }),
     }),
+    createResolver({
+      intent: AssistantAction.SetCurrentChat,
+      resolve: ({ companionTo, chat }) =>
+        Effect.gen(function* () {
+          const state = context.getCapability(AssistantCapabilities.MutableState);
+          state.currentChat[fullyQualifiedId(companionTo)] = chat;
+        }),
+    }),
   ]),
 ];

package/src/capabilities/local-model-resolver.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OpenAiClient } from '@effect/ai-openai';
+import { FetchHttpClient } from '@effect/platform';
+import { Layer } from 'effect';
+
+import { AiServiceRouter } from '@dxos/ai';
+import { type Capability, contributes } from '@dxos/app-framework';
+
+import { AssistantCapabilities } from './capabilities';
+
+/**
+ * To start LM Studio server:
+ * ```bash
+ * ~/.lmstudio/bin/lms server start --cors
+ * ```
+ */
+export default (): Capability<any>[] => [
+  contributes(
+    AssistantCapabilities.AiModelResolver,
+    AiServiceRouter.LMStudioResolver.pipe(
+      Layer.provide(
+        OpenAiClient.layer({
+          apiUrl: AiServiceRouter.LMSTUDIO_ENDPOINT,
+        }),
+      ),
+      Layer.provide(FetchHttpClient.layer),
+    ),
+  ),
+];

package/src/capabilities/react-surface.tsx

@@ -2,28 +2,27 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
-import React, { useEffect, useMemo } from 'react';
+import React from 'react';
 
-import { Capabilities, contributes, createIntent, createSurface, useIntentDispatcher } from '@dxos/app-framework';
-import { Template } from '@dxos/blueprints';
-import { fullyQualifiedId, getSpace, getTypename } from '@dxos/client/echo';
+import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
+import { Blueprint } from '@dxos/blueprints';
+import { getSpace } from '@dxos/client/echo';
 import { Sequence } from '@dxos/conductor';
 import { InvocationTraceContainer } from '@dxos/devtools';
-import { Filter, type Key, Obj, Query } from '@dxos/echo';
+import { Obj } from '@dxos/echo';
 import { SettingsStore } from '@dxos/local-storage';
-import { SpaceAction } from '@dxos/plugin-space/types';
 import { StackItem } from '@dxos/react-ui-stack';
 
 import {
   AssistantSettings,
+  BlueprintContainer,
+  ChatCompanion,
   ChatContainer,
   ChatDialog,
   PromptSettings,
   SequenceContainer,
-  TemplateContainer,
 } from '../components';
-import { meta, ASSISTANT_DIALOG } from '../meta';
+import { ASSISTANT_DIALOG, meta } from '../meta';
 import { Assistant } from '../types';
 
 export default () =>
@@ -43,59 +42,12 @@ export default () =>
       component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
     }),
     createSurface({
-      id: `${meta.id}/object-chat`,
+      id: `${meta.id}/companion-chat`,
       role: 'article',
       filter: (data): data is { companionTo: Obj.Any; subject: Assistant.Chat | 'assistant-chat' } =>
         Obj.isObject(data.companionTo) &&
         (Obj.instanceOf(Assistant.Chat, data.subject) || data.subject === 'assistant-chat'),
-      component: ({ data, role }) => {
-        const { dispatch } = useIntentDispatcher();
-        const associatedArtifact = useMemo(
-          () => ({
-            id: fullyQualifiedId(data.companionTo),
-            typename: getTypename(data.companionTo) ?? 'unknown',
-            spaceId: (getSpace(data.companionTo)?.id ?? 'unknown') as Key.SpaceId,
-          }),
-          [data.companionTo],
-        );
-
-        // TODO(wittjosiah): Factor out to container.
-        useEffect(() => {
-          const timeout = setTimeout(async () => {
-            const space = getSpace(data.companionTo);
-            if (space && data.subject === 'assistant-chat') {
-              const result = await space.db
-                .query(Query.select(Filter.ids(data.companionTo.id)).targetOf(Assistant.CompanionTo).source())
-                .run();
-              if (result.objects.length > 0) {
-                return;
-              }
-
-              const program = Effect.gen(function* () {
-                const { object } = yield* dispatch(createIntent(Assistant.CreateChat, { space }));
-                yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-                yield* dispatch(
-                  createIntent(SpaceAction.AddRelation, {
-                    space,
-                    schema: Assistant.CompanionTo,
-                    source: object,
-                    target: data.companionTo,
-                  }),
-                );
-              });
-              void Effect.runPromise(program);
-            }
-          });
-
-          return () => clearTimeout(timeout);
-        }, [data.subject]);
-
-        if (data.subject === 'assistant-chat') {
-          return null;
-        }
-
-        return <ChatContainer role={role} chat={data.subject} artifact={associatedArtifact} />;
-      },
+      component: ({ data, role }) => <ChatCompanion role={role} data={data} />,
     }),
     createSurface({
       id: `${meta.id}/sequence`,
@@ -104,10 +56,11 @@ export default () =>
       component: ({ data }) => <SequenceContainer sequence={data.subject} />,
     }),
     createSurface({
-      id: `${meta.id}/companion/logs`,
+      id: `${meta.id}/companion-logs`,
       role: 'article',
       filter: (data): data is { companionTo: Sequence } =>
         Obj.instanceOf(Sequence, data.companionTo) && data.subject === 'logs',
+      // eslint-disable-next-line unused-imports/no-unused-vars
       component: ({ data, role }) => {
         const space = getSpace(data.companionTo);
         return (
@@ -118,16 +71,16 @@ export default () =>
       },
     }),
     createSurface({
-      id: `${meta.id}/template`,
+      id: `${meta.id}/blueprint`,
       role: 'article',
-      filter: (data): data is { subject: Template.Template } => Obj.instanceOf(Template.Template, data.subject),
-      component: ({ data }) => <TemplateContainer template={data.subject} />,
+      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
+      component: ({ data }) => <BlueprintContainer blueprint={data.subject} />,
     }),
     createSurface({
       id: `${meta.id}/prompt-settings`,
       role: 'object-settings',
-      filter: (data): data is { subject: Template.Template } => Obj.instanceOf(Template.Template, data.subject),
-      component: ({ data }) => <PromptSettings template={data.subject} />,
+      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
+      component: ({ data }) => <PromptSettings template={data.subject.instructions} />,
     }),
     createSurface({
       id: ASSISTANT_DIALOG,

package/src/capabilities/state.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes } from '@dxos/app-framework';
+import { LocalStorageStore } from '@dxos/local-storage';
+
+import { meta } from '../meta';
+
+import { AssistantCapabilities } from './capabilities';
+
+export default () => {
+  // NOTE: This needs to be a chat object rather than a string id to avoid a query race.
+  // TODO(wittjosiah): Handle serialization and hydration for this so it can be cached.
+  const state = new LocalStorageStore<AssistantCapabilities.AssistantState>(meta.id, {
+    currentChat: {},
+  });
+
+  return contributes(AssistantCapabilities.State, state.values, () => state.close());
+};