@dxos/plugin-assistant 0.8.4-main.67995b8 → 0.8.4-main.ae835ea

package/src/testing/test-generator.ts

@@ -0,0 +1,261 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Obj } from '@dxos/echo';
+import { ContextQueueService, DatabaseService } from '@dxos/functions';
+import { faker } from '@dxos/random';
+import { renderObjectLink } from '@dxos/react-ui-components';
+import { type ContentBlock, DataType } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+export const createMessage = (role: DataType.ActorRole, blocks: ContentBlock.Any[]): DataType.Message => {
+  return Obj.make(DataType.Message, {
+    created: new Date().toISOString(),
+    sender: { role },
+    blocks,
+  });
+};
+
+export type MessageGenerator = Effect.Effect<void, never, DatabaseService | ContextQueueService>;
+
+export const createMessageGenerator = (): MessageGenerator[] => [
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('user', [
+          {
+            _tag: 'text',
+            text: faker.lorem.sentence(5),
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('assistant', [
+          {
+            _tag: 'text',
+            text:
+              trim`
+              ## Markdown
+              Here is a [link](https://dxos.org)
+
+              And some **bold** text.
+
+              And some JSON
+              \`\`\`json
+              {
+                "key": "value"
+              }
+              \`\`\`
+
+              And some code
+              \`\`\`js
+              const x = 1;
+              \`\`\`
+            ` + '\n',
+          },
+          {
+            _tag: 'text',
+            disposition: 'cot',
+            text:
+              [
+                faker.lorem.paragraph(),
+                '',
+                ...Array.from({ length: faker.number.int({ min: 3, max: 5 }) }).map(
+                  (_, idx) => `${idx + 1}. ${faker.lorem.paragraph()}`,
+                ),
+              ].join('\n') + '\n',
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('assistant', [
+          {
+            _tag: 'text',
+            text: 'How can I help?',
+          },
+          {
+            _tag: 'suggestion',
+            text: 'List tools',
+          },
+          {
+            _tag: 'suggestion',
+            text: 'Show info',
+          },
+          {
+            _tag: 'suggestion',
+            text: faker.lorem.paragraph(),
+          },
+        ]),
+        createMessage('assistant', [
+          {
+            _tag: 'text',
+            text: 'Select an option:',
+          },
+          {
+            _tag: 'select',
+            options: ['Option 1', 'Option 2', 'Option 3'],
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('assistant', [
+          {
+            _tag: 'toolkit',
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('user', [
+          {
+            _tag: 'text',
+            text: faker.lorem.sentence(5),
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    const { db } = yield* DatabaseService;
+    const obj1 = db.add(Obj.make(DataType.Organization, { name: 'DXOS' }));
+    // const obj2 = db.add(Obj.make(DataType.Person, { fullName: 'Alice' }));
+    // const obj3 = db.add(Obj.make(DataType.Person, { fullName: 'Bob' }));
+    // const obj4 = db.add(Obj.make(DataType.Person, { fullName: 'Charlie' }));
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('assistant', [
+          // Inline tag.
+          {
+            _tag: 'text',
+            text: [faker.lorem.paragraph(), renderObjectLink(obj1), faker.lorem.paragraph(), '\n'].join(' '),
+          },
+
+          // Inline cards.
+          // ...[obj1, obj2, obj3, obj4].map(
+          //   (obj) =>
+          //     ({
+          //       _tag: 'text',
+          //       text: renderObjectLink(obj, true) + '\n',
+          //     }) satisfies ContentBlock.Text,
+          // ),
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('assistant', [
+          {
+            _tag: 'text',
+            text: faker.lorem.paragraph() + '\n',
+          },
+        ]),
+        createMessage('assistant', [
+          {
+            _tag: 'toolCall',
+            toolCallId: '1234',
+            name: 'search',
+            input: JSON.stringify({}),
+            providerExecuted: false,
+          },
+        ]),
+        createMessage('user', [
+          {
+            _tag: 'toolResult',
+            toolCallId: '1234',
+            name: 'search',
+            result: 'This is a tool result.',
+            providerExecuted: false,
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('assistant', [
+          {
+            _tag: 'text',
+            text: faker.lorem.paragraph() + '\n',
+          },
+        ]),
+        createMessage('assistant', [
+          {
+            _tag: 'toolCall',
+            toolCallId: '4567',
+            name: 'create',
+            input: JSON.stringify({}),
+            providerExecuted: false,
+          },
+        ]),
+        createMessage('user', [
+          {
+            _tag: 'toolResult',
+            toolCallId: '4567',
+            name: 'create',
+            result: 'This is a tool result.',
+            providerExecuted: false,
+          },
+        ]),
+        createMessage('assistant', [
+          {
+            _tag: 'text',
+            text:
+              Array.from({ length: faker.number.int({ min: 2, max: 3 }) })
+                .map(() => faker.lorem.paragraph())
+                .join('\n\n') + '\n',
+          },
+        ]),
+      ]),
+    );
+  }),
+
+  Effect.gen(function* () {
+    const { queue } = yield* ContextQueueService;
+    yield* Effect.promise(() =>
+      queue.append([
+        createMessage('assistant', [
+          {
+            _tag: 'text',
+            text: faker.lorem.paragraph(),
+          },
+        ]),
+      ]),
+    );
+  }),
+];

package/src/testing/test-sequence.ts

@@ -2,33 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ToolId, ToolRegistry } from '@dxos/ai';
-// import { createExaTool, createGraphWriterTool, createLocalSearchTool } from '@dxos/assistant';
-import { type Space } from '@dxos/client/echo';
-import { SequenceParser, type SequenceDefinition } from '@dxos/conductor';
-import { type DXN } from '@dxos/keys';
-import { isNonNullable } from '@dxos/util';
-
-// TODO(dmaretskyi): make db available through services (same as function executor).
-// TODO(burdon): Can tools implement "aspects" so that variants can be used rather than an explicit reference?
-export const createToolRegistry = (space: Space, queueDxn?: DXN): ToolRegistry => {
-  return new ToolRegistry(
-    [
-      // createExaTool({ apiKey: EXA_API_KEY }),
-      // createLocalSearchTool(space.db, queueDxn && space.queues.get(queueDxn)),
-      // queueDxn &&
-      //   createGraphWriterTool({
-      //     db: space.db,
-      //     queue: space.queues.get(queueDxn),
-      //     schema: DataTypes,
-      //     onDone: async (objects) => {
-      //       const queue = space.queues.get(queueDxn);
-      //       await queue.append(objects);
-      //     },
-      //   }),
-    ].filter(isNonNullable),
-  );
-};
+import { ToolId } from '@dxos/ai';
+import { type SequenceDefinition, SequenceParser } from '@dxos/conductor';
 
 export const RESEARCH_SEQUENCE_DEFINITION: SequenceDefinition = {
   steps: [

package/src/testing/test-services.ts

@@ -4,16 +4,10 @@
 
 import { Obj } from '@dxos/echo';
 
-import {
-  type ApiAuthorization,
-  type BaseServiceRegistry,
-  type ServiceQuery,
-  ServiceType,
-  categoryIcons,
-} from '../types';
+import { type ApiAuthorization, type BaseServiceRegistry, ServiceType, categoryIcons } from '../types';
 
 export class MockServiceRegistry implements BaseServiceRegistry {
-  async queryServices(query?: ServiceQuery): Promise<ServiceType[]> {
+  async queryServices(): Promise<ServiceType[]> {
     return TEST_SERVICES;
   }
 }

package/src/toolkits/AssistantToolkit.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
+import * as Effect from 'effect/Effect';
+import type * as Layer from 'effect/Layer';
+import * as Record from 'effect/Record';
+import * as Schema from 'effect/Schema';
+
+import { type PluginContext } from '@dxos/app-framework';
+import { AiContextService, ArtifactId } from '@dxos/assistant';
+import { Ref } from '@dxos/echo';
+import { DatabaseService } from '@dxos/functions';
+import { trim } from '@dxos/util';
+
+const Toolkit$ = Toolkit.make(
+  Tool.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,
+    dependencies: [AiContextService, DatabaseService],
+  }),
+);
+
+export namespace AssistantToolkit {
+  export const Toolkit = Toolkit$;
+
+  export const tools = Record.keys(Toolkit$.tools);
+
+  export const createLayer = (
+    _context: PluginContext,
+  ): Layer.Layer<Tool.Handler<any>, never, AiContextService | DatabaseService> =>
+    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],
+          }),
+        );
+      }),
+    });
+}

package/src/toolkits/SystemToolkit.ts

@@ -0,0 +1,292 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
+import * as Effect from 'effect/Effect';
+import type * as Layer from 'effect/Layer';
+import * as Record from 'effect/Record';
+import * as Schema from 'effect/Schema';
+
+import { Capabilities, type PluginContext, createIntent } from '@dxos/app-framework';
+import { ArtifactId } from '@dxos/assistant';
+import { DXN, Filter, Obj, Relation, SchemaNotFoundError, Tag, 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';
+
+// TODO(burdon): Factor out (is there a way to remove plugin deps?)
+// TODO(burdon): Reconcile with functions (currently reuses plugin framework intents).
+
+const Toolkit$ = Toolkit.make(
+  //
+  // Schema
+  //
+
+  Tool.make('schema-list', {
+    description: trim`
+      Lists 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,
+  }),
+
+  Tool.make('schema-add', {
+    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,
+  }),
+
+  //
+  // Objects
+  //
+
+  Tool.make('object-create', {
+    description: trim`
+      Creates a new object and adds it to the current space.
+      Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
+    `,
+    parameters: {
+      typename: Schema.String,
+      data: Schema.Any,
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+
+  Tool.make('object-remove', {
+    description: trim`
+      Removes an object or relation from the database.
+    `,
+    parameters: {
+      id: ArtifactId.annotations({
+        description: 'The ID of the object.',
+      }),
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+
+  //
+  // Relations
+  //
+
+  Tool.make('relation-create', {
+    description: trim`
+      Creates a new relation and adds it to the current space.
+      Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
+    `,
+    parameters: {
+      typename: Schema.String,
+      source: ArtifactId.annotations({
+        description: 'The ID of the source object.',
+      }),
+      target: ArtifactId.annotations({
+        description: 'The ID of the target object.',
+      }),
+      data: Schema.Any.annotations({
+        description: 'The data to be stored in the relation.',
+      }),
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+
+  //
+  // Tags
+  //
+
+  Tool.make('tag-add', {
+    description: trim`
+      Adds a tag to an object.
+      Tags are objects of type ${Tag.Tag.typename}.
+    `,
+    parameters: {
+      tagId: ArtifactId.annotations({
+        description: 'The ID of the tag.',
+      }),
+      objectId: ArtifactId.annotations({
+        description: 'The ID of the object.',
+      }),
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+
+  Tool.make('tag-remove', {
+    description: trim`
+      Removes a tag from an object.
+      Tags are objects of type ${Tag.Tag.typename}.
+    `,
+    parameters: {
+      tagId: ArtifactId.annotations({
+        description: 'The ID of the tag.',
+      }),
+      objectId: ArtifactId.annotations({
+        description: 'The ID of the object.',
+      }),
+    },
+    success: Schema.Any,
+    failure: Schema.Never,
+  }),
+);
+
+export namespace SystemToolkit {
+  export const Toolkit = Toolkit$;
+
+  export const tools = Record.keys(Toolkit$.tools);
+
+  export const createLayer = (context: PluginContext): Layer.Layer<Tool.Handler<any>, never, never> =>
+    Toolkit$.toLayer({
+      'schema-list': () => {
+        const space = getActiveSpace(context);
+        invariant(space, 'No active space');
+
+        return Effect.gen(function* () {
+          const registered = context
+            // TODO(burdon): Can we remove plugin dependency? Get from layer?
+            .getCapabilities(ClientCapabilities.Schema)
+            .flat()
+            .map((schema) => {
+              const meta = Type.getMeta(schema);
+              return {
+                typename: Type.getTypename(schema),
+                jsonSchema: Type.toJsonSchema(schema),
+                kind: meta?.sourceSchema ? 'relation' : 'record',
+              };
+            });
+
+          // TODO(burdon): Can we remove plugin dependency? Get from layer?
+          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
+            typename: Type.getTypename(form.objectSchema),
+            jsonSchema: Type.toJsonSchema(form.objectSchema),
+            kind: 'item',
+          }));
+
+          const schemas = [...registered, ...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)));
+      },
+
+      'schema-add': ({ 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);
+      },
+
+      'object-create': ({ 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.Schema).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 SchemaNotFoundError(typename);
+          }
+
+          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);
+      },
+
+      'object-remove': ({ id }) => {
+        const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+        const space = getActiveSpace(context);
+        invariant(space, 'No active space');
+
+        return Effect.gen(function* () {
+          const object = yield* DatabaseService.resolve(DXN.parse(id));
+          yield* dispatch(createIntent(SpaceAction.RemoveObjects, { objects: [object] }));
+          return object;
+        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
+      },
+
+      'relation-create': ({ typename, source, target, 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.Schema).flat();
+          const schema = schemas.find((schema) => Type.getTypename(schema) === typename);
+          if (!schema) {
+            throw new SchemaNotFoundError(typename);
+          }
+
+          const sourceObj = yield* DatabaseService.resolve(DXN.parse(source));
+          const targetObj = yield* DatabaseService.resolve(DXN.parse(target));
+          const relation = Relation.make(schema, {
+            [Relation.Source]: sourceObj,
+            [Relation.Target]: targetObj,
+            ...data,
+          });
+          yield* dispatch(createIntent(SpaceAction.AddObject, { object: relation, target: space, hidden: true }));
+          return relation;
+        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
+      },
+
+      'tag-add': ({ tagId, objectId }) => {
+        const space = getActiveSpace(context);
+        invariant(space, 'No active space');
+
+        return Effect.gen(function* () {
+          const object = yield* DatabaseService.resolve(DXN.parse(objectId));
+          const meta = Obj.getMeta(object);
+          meta.tags = [DXN.parse(tagId).toString()];
+          return object;
+        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
+      },
+
+      'tag-remove': ({ tagId, objectId }) => {
+        const space = getActiveSpace(context);
+        invariant(space, 'No active space');
+
+        return Effect.gen(function* () {
+          const object = yield* DatabaseService.resolve(DXN.parse(objectId));
+          const meta = Obj.getMeta(object);
+          meta.tags = meta.tags?.filter((tag) => tag !== DXN.parse(tagId).toString());
+          return object;
+        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
+      },
+    });
+}

package/src/toolkits/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './AssistantToolkit';
+export * from './SystemToolkit';