@dxos/plugin-assistant 0.8.4-main.5ea62a8 → 0.8.4-main.ae835ea

package/src/capabilities/blueprint-definition.ts

@@ -4,31 +4,39 @@
 
 import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
 import { templates } from '@dxos/assistant';
+import {
+  Agent,
+  Discord,
+  DiscordBlueprint,
+  EntityExtraction,
+  Linear,
+  LinearBlueprint,
+  Research,
+  ResearchBlueprint,
+  WebSearchBlueprint,
+} from '@dxos/assistant-toolkit';
 import { Blueprint } from '@dxos/blueprints';
 import { type FunctionDefinition } from '@dxos/functions';
 
 import { analysis, list, load } from '../functions';
+import { AssistantToolkit, SystemToolkit } from '../toolkits';
+
+// TODO(burdon): Function naming pattern (noun-verb); fully-qualified?
+// TODO(burdon): Document plugin structure (blueprint, functions, toolkit.)
+// TODO(burdon): Test framework for developing functions. Error handling.
+// TODO(burdon): Convert tools to functions? (Deps).
+
+// TODO(wittjosiah): Factor out to a generic app-framework blueprint.
+const deckTools = ['open-item'];
 
 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',
-];
+const tools = [...AssistantToolkit.tools, ...SystemToolkit.tools, ...deckTools];
 
-export const BLUEPRINT_KEY = 'dxos.org/blueprint/assistant';
+export const ASSISTANT_BLUEPRINT_KEY = 'dxos.org/blueprint/assistant';
 
 export const createBlueprint = (): Blueprint.Blueprint =>
   Blueprint.make({
-    key: BLUEPRINT_KEY,
+    key: ASSISTANT_BLUEPRINT_KEY,
     name: 'Assistant',
     tools: Blueprint.toolDefinitions({ functions, tools }),
     instructions: templates.system,
@@ -39,4 +47,20 @@ const blueprint = createBlueprint();
 export default (): Capability<any>[] => [
   contributes(Capabilities.Functions, functions),
   contributes(Capabilities.BlueprintDefinition, blueprint),
+
+  // TODO(burdon): Factor out.
+  contributes(Capabilities.Functions, [Research.create, Research.research]),
+  contributes(Capabilities.BlueprintDefinition, ResearchBlueprint),
+
+  // TODO(burdon): Factor out.
+  contributes(Capabilities.Functions, [Agent.prompt, EntityExtraction.extract]),
+  contributes(Capabilities.BlueprintDefinition, WebSearchBlueprint),
+
+  // TODO(burdon): Factor out.
+  contributes(Capabilities.Functions, [Discord.fetch]),
+  contributes(Capabilities.BlueprintDefinition, DiscordBlueprint),
+
+  // TODO(burdon): Factor out.
+  contributes(Capabilities.Functions, [Linear.sync]),
+  contributes(Capabilities.BlueprintDefinition, LinearBlueprint),
 ];

package/src/capabilities/capabilities.ts

@@ -2,9 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Layer } from 'effect';
-
-import { type AiService, type AiServiceRouter } from '@dxos/ai';
 import { defineCapability } from '@dxos/app-framework';
 import { type DeepReadonly } from '@dxos/util';
 
@@ -18,14 +15,4 @@ export namespace AssistantCapabilities {
   };
   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`,
-  );
 }

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

@@ -3,17 +3,15 @@
 //
 
 import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
-import { FetchHttpClient } from '@effect/platform';
-import { Layer } from 'effect';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as Layer from 'effect/Layer';
 
-import { AiServiceRouter } from '@dxos/ai';
-import { type Capability, contributes } from '@dxos/app-framework';
-
-import { AssistantCapabilities } from './capabilities';
+import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
+import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
 
 export default (): Capability<any>[] => [
   contributes(
-    AssistantCapabilities.AiModelResolver,
+    Capabilities.AiModelResolver,
     AiServiceRouter.AnthropicResolver.pipe(
       Layer.provide(
         AnthropicClient.layer({

package/src/capabilities/intent-resolver.ts

@@ -2,25 +2,31 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
 import { Capabilities, type PluginContext, contributes, createIntent, createResolver } from '@dxos/app-framework';
-import { AiContextBinder } from '@dxos/assistant';
+import { AiContextBinder, AiConversation } from '@dxos/assistant';
 import { Blueprint, Template } from '@dxos/blueprints';
 import { fullyQualifiedId } from '@dxos/client/echo';
+import { type Queue } from '@dxos/client/echo';
 import { Sequence } from '@dxos/conductor';
 import { Filter, Key, Obj, Ref } from '@dxos/echo';
+import { TracingService } from '@dxos/functions';
+import { AutomationCapabilities } from '@dxos/plugin-automation';
 import { CollectionAction } from '@dxos/plugin-space/types';
+import { getSpace } from '@dxos/react-client/echo';
+import { type DataType } from '@dxos/schema';
 
+import { type AiChatServices, updateName } from '../processor';
 import { Assistant, AssistantAction } from '../types';
 
-import { BLUEPRINT_KEY, createBlueprint } from './blueprint-definition';
+import { ASSISTANT_BLUEPRINT_KEY, createBlueprint } from './blueprint-definition';
 import { AssistantCapabilities } from './capabilities';
 
 export default (context: PluginContext) => [
   contributes(Capabilities.IntentResolver, [
     createResolver({
-      intent: AssistantAction.OnSpaceCreated,
+      intent: AssistantAction.onCreateSpace,
       resolve: ({ space, rootCollection }) =>
         Effect.gen(function* () {
           const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
@@ -41,23 +47,44 @@ export default (context: PluginContext) => [
       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 chat = Assistant.makeChat({ name, queue });
         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);
+        let defaultBlueprint = blueprints.find((blueprint) => blueprint.key === ASSISTANT_BLUEPRINT_KEY);
         if (!defaultBlueprint) {
           defaultBlueprint = space.db.add(createBlueprint());
         }
 
         const binder = new AiContextBinder(queue);
+        await binder.open();
         await binder.bind({ blueprints: [Ref.make(defaultBlueprint)] });
+        await binder.close();
 
         return {
           data: { object: chat },
         };
       },
     }),
+    createResolver({
+      intent: AssistantAction.UpdateChatName,
+      resolve: async ({ chat }) => {
+        const space = getSpace(chat);
+        const queue = chat.queue.target as Queue<DataType.Message>;
+        if (!space || !queue) {
+          return;
+        }
+
+        const runtimeResolver = context.getCapability(AutomationCapabilities.ComputeRuntime);
+        const runtime = await runtimeResolver.getRuntime(space.id).runPromise(
+          Effect.gen(function* () {
+            return yield* Effect.runtime<AiChatServices>().pipe(Effect.provide(TracingService.layerNoop));
+          }),
+        );
+
+        await new AiConversation(queue).use(async (conversation) => updateName(runtime, conversation, chat));
+      },
+    }),
     createResolver({
       intent: AssistantAction.CreateBlueprint,
       resolve: ({ key, name, description }) => ({

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

@@ -2,14 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { OpenAiClient } from '@effect/ai-openai';
-import { FetchHttpClient } from '@effect/platform';
-import { Layer } from 'effect';
+import * as OpenAiClient from '@effect/ai-openai/OpenAiClient';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as Layer from 'effect/Layer';
 
-import { AiServiceRouter } from '@dxos/ai';
-import { type Capability, contributes } from '@dxos/app-framework';
-
-import { AssistantCapabilities } from './capabilities';
+import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
+import { Capabilities, type Capability, contributes } from '@dxos/app-framework';
 
 /**
  * To start LM Studio server:
@@ -19,7 +17,7 @@ import { AssistantCapabilities } from './capabilities';
  */
 export default (): Capability<any>[] => [
   contributes(
-    AssistantCapabilities.AiModelResolver,
+    Capabilities.AiModelResolver,
     AiServiceRouter.LMStudioResolver.pipe(
       Layer.provide(
         OpenAiClient.layer({

package/src/capabilities/react-surface.tsx

@@ -13,15 +13,7 @@ import { Obj } from '@dxos/echo';
 import { SettingsStore } from '@dxos/local-storage';
 import { StackItem } from '@dxos/react-ui-stack';
 
-import {
-  AssistantSettings,
-  BlueprintContainer,
-  ChatCompanion,
-  ChatContainer,
-  ChatDialog,
-  PromptSettings,
-  SequenceContainer,
-} from '../components';
+import { AssistantSettings, BlueprintContainer, ChatCompanion, ChatContainer, ChatDialog } from '../components';
 import { ASSISTANT_DIALOG, meta } from '../meta';
 import { Assistant } from '../types';
 
@@ -49,12 +41,6 @@ export default () =>
         (Obj.instanceOf(Assistant.Chat, data.subject) || data.subject === 'assistant-chat'),
       component: ({ data, role }) => <ChatCompanion role={role} data={data} />,
     }),
-    createSurface({
-      id: `${meta.id}/sequence`,
-      role: 'article',
-      filter: (data): data is { subject: Sequence } => Obj.instanceOf(Sequence, data.subject),
-      component: ({ data }) => <SequenceContainer sequence={data.subject} />,
-    }),
     createSurface({
       id: `${meta.id}/companion-logs`,
       role: 'article',
@@ -76,12 +62,6 @@ export default () =>
       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: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
-      component: ({ data }) => <PromptSettings template={data.subject.instructions} />,
-    }),
     createSurface({
       id: ASSISTANT_DIALOG,
       role: 'dialog',

package/src/capabilities/toolkit.ts

@@ -2,162 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { AiTool, AiToolkit } from '@effect/ai';
-import { Effect, Schema } from 'effect';
+import { Capabilities, type Capability, type PluginContext, contributes } from '@dxos/app-framework';
+import { WebSearchToolkit } from '@dxos/assistant-toolkit';
 
-import { Capabilities, type Capability, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { AiContextService, ArtifactId } from '@dxos/assistant';
-import { Filter, Obj, Ref, Type } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { invariant } from '@dxos/invariant';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { SpaceCapabilities, getActiveSpace } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { DataType } from '@dxos/schema';
-import { trim } from '@dxos/util';
+import { AssistantToolkit, SystemToolkit } from '../toolkits';
 
-// TODO(burdon): Reconcile with functions (currently reuses plugin framework intents).
-class Toolkit extends AiToolkit.make(
-  AiTool.make('add-to-context', {
-    description: trim`
-      Adds the object to the chat context.
-    `,
-    parameters: {
-      id: ArtifactId.annotations({
-        description: 'The ID of the document to read.',
-      }),
-    },
-    success: Schema.Void,
-    failure: Schema.Never,
-  }).addRequirement<AiContextService | DatabaseService>(), // TODO(burdon): Define standard contract.
-
-  AiTool.make('get-schemas', {
-    description: trim`
-      Retrieves schemas definitions.
-    `,
-    parameters: {
-      // TODO(wittjosiah): Remove this once parameter-less tools are fixed.
-      limit: Schema.Number,
-    },
-    // TODO(dmaretskyi): Effect returns ({ result, encodedResult })
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  AiTool.make('add-schema', {
-    description: trim`
-      Adds a schema to the space.
-      The name will be used when displayed to the user.
-      The typename must be in the format of "example.com/type/Type".
-    `,
-    parameters: {
-      name: Schema.String,
-      typename: Schema.String,
-      jsonSchema: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  AiTool.make('create-record', {
-    description: trim`
-      Creates a new record and adds it to the current space.
-      Get the schema from the get-schemas tool and ensure that the data matches the corresponding schema.
-      Note that only record schemas are supported.
-    `,
-    parameters: {
-      typename: Schema.String,
-      data: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-) {
-  static layer = (context: PluginContext) =>
-    Toolkit.toLayer({
-      'add-to-context': Effect.fnUntraced(function* ({ id }) {
-        const { binder } = yield* AiContextService;
-        const { db } = yield* DatabaseService;
-        const ref = Ref.fromDXN(ArtifactId.toDXN(id, db.spaceId));
-        yield* Effect.promise(() =>
-          binder.bind({
-            blueprints: [],
-            objects: [ref],
-          }),
-        );
-      }),
-
-      'get-schemas': () => {
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const whitelist = context
-            .getCapabilities(ClientCapabilities.SchemaWhiteList)
-            .flat()
-            .map((schema) => ({
-              typename: Type.getTypename(schema),
-              jsonSchema: Type.toJsonSchema(schema),
-              kind: 'record',
-            }));
-
-          // TODO(burdon): Why ObjectForm (bad name for data capability; UI term)?
-          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
-            typename: Type.getTypename(form.objectSchema),
-            jsonSchema: Type.toJsonSchema(form.objectSchema),
-            kind: 'item',
-          }));
-
-          const schemas = [...whitelist, ...forms];
-          if (space) {
-            const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-            schemas.push(
-              ...objects.map((object) => ({
-                typename: object.typename,
-                jsonSchema: object.jsonSchema,
-                kind: 'record',
-              })),
-            );
-          }
-
-          return schemas;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)));
-      },
-
-      'add-schema': ({ name, typename, jsonSchema }) => {
-        return Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const space = getActiveSpace(context);
-          invariant(space, 'No active space');
-
-          const schema = Type.toEffectSchema(jsonSchema).pipe(Type.Obj({ typename, version: '0.1.0' }));
-          yield* dispatch(createIntent(SpaceAction.AddSchema, { space, name, typename, schema }));
-        }).pipe(Effect.orDie);
-      },
-
-      'create-record': ({ typename, data }) => {
-        const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const schemas = context.getCapabilities(ClientCapabilities.SchemaWhiteList).flat();
-          const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-          schemas.push(...objects.map((object) => Type.toEffectSchema(object.jsonSchema)));
-          const schema = schemas.find((schema) => Type.getTypename(schema) === typename);
-          if (!schema) {
-            throw new Error(`Schema not found for ${typename}`);
-          }
+export default (context: PluginContext): Capability<any>[] => [
+  contributes(Capabilities.Toolkit, AssistantToolkit),
+  contributes(Capabilities.ToolkitHandler, AssistantToolkit.createLayer(context)),
 
-          const object = Obj.make(schema, data);
-          yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-          return object;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
-      },
-    });
-}
+  // TODO(burdon): How to manage dependencies?
+  contributes(Capabilities.Toolkit, SystemToolkit.Toolkit),
+  contributes(Capabilities.ToolkitHandler, SystemToolkit.createLayer(context)),
 
-export default (context: PluginContext): Capability<any>[] => [
-  contributes(Capabilities.Toolkit, Toolkit),
-  contributes(Capabilities.ToolkitHandler, Toolkit.layer(context)),
+  contributes(Capabilities.Toolkit, WebSearchToolkit),
 ];

package/src/components/BlueprintContainer.tsx

@@ -5,6 +5,9 @@
 import React from 'react';
 
 import { type Blueprint } from '@dxos/blueprints';
+import { fullyQualifiedId } from '@dxos/react-client/echo';
+import { Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
 import { StackItem } from '@dxos/react-ui-stack';
 
 import { TemplateEditor } from './TemplateEditor';
@@ -14,9 +17,12 @@ export type BlueprintContainerProps = {
 };
 
 export const BlueprintContainer = ({ blueprint }: BlueprintContainerProps) => {
+  const { hasAttention } = useAttention(fullyQualifiedId(blueprint));
+
   return (
-    <StackItem.Content classNames='container-max-width'>
-      <TemplateEditor id={blueprint.id} template={blueprint.instructions} />
+    <StackItem.Content toolbar>
+      <Toolbar.Root disabled={!hasAttention} />
+      <TemplateEditor id={blueprint.id} template={blueprint.instructions} classNames='container-max-width' />
     </StackItem.Content>
   );
 };