@dxos/assistant-toolkit 0.8.4-main.e8ec1fe → 0.8.4-main.fcfe5033a5

package/src/toolkits/AssistantToolkit.test.ts

@@ -1,88 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, expect, it } from '@effect/vitest';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-
-import { AiService, ConsolePrinter, MemoizedAiService } from '@dxos/ai';
-import { TestAiService } from '@dxos/ai/testing';
-import {
-  AiConversation,
-  type ContextBinding,
-  GenerationObserver,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
-} from '@dxos/assistant';
-import { Blueprint, Template } from '@dxos/blueprints';
-import { Obj } from '@dxos/echo';
-import { Ref } from '@dxos/echo';
-import { TestHelpers, acquireReleaseResource } from '@dxos/effect';
-import { CredentialsService, DatabaseService, QueueService, TracingService } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
-import { ObjectId } from '@dxos/keys';
-import { Message, Organization, Person } from '@dxos/types';
-
-import * as AssistantToolkit from './AssistantToolkit';
-
-ObjectId.dangerouslyDisableRandomness();
-
-const TestLayer = Layer.mergeAll(
-  AiService.model('@anthropic/claude-opus-4-0'),
-  makeToolResolverFromFunctions([], AssistantToolkit.AssistantToolkit),
-  makeToolExecutionServiceFromFunctions(AssistantToolkit.AssistantToolkit, AssistantToolkit.layer()),
-).pipe(
-  Layer.provideMerge(FunctionInvocationServiceLayerTest()),
-  Layer.provideMerge(
-    Layer.mergeAll(
-      TestAiService(),
-      TestDatabaseLayer({
-        spaceKey: 'fixed',
-        indexing: { vector: true },
-        types: [Blueprint.Blueprint, Message.Message, Person.Person, Organization.Organization],
-      }),
-      CredentialsService.configuredLayer([]),
-      TracingService.layerNoop,
-    ),
-  ),
-);
-
-const blueprint = Blueprint.make({
-  key: 'dxos.org/blueprint/assistant',
-  name: 'Assistant',
-  tools: Blueprint.toolDefinitions({ tools: AssistantToolkit.tools }),
-  instructions: Template.make(),
-});
-
-describe('AssistantToolkit', () => {
-  it.scoped(
-    'can add to context',
-    Effect.fnUntraced(
-      function* (_) {
-        const { db } = yield* DatabaseService;
-        const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation(queue));
-        const observer = GenerationObserver.fromPrinter(new ConsolePrinter());
-        yield* Effect.promise(() => conversation.context.bind({ blueprints: [Ref.make(db.add(blueprint))] }));
-
-        const organization = yield* DatabaseService.add(
-          Obj.make(Organization.Organization, {
-            name: 'Cyberdyne Systems',
-            website: 'https://cyberdyne.com',
-          }),
-        );
-
-        yield* conversation.createRequest({
-          prompt: `Add to context: ${JSON.stringify(organization)}`,
-          observer,
-        });
-
-        expect(conversation.context.objects.value).toEqual([Ref.make(organization)]);
-      },
-      Effect.provide(TestLayer),
-      TestHelpers.provideTestContext,
-    ),
-    MemoizedAiService.isGenerationEnabled() ? 60_000 : undefined,
-  );
-});

package/src/toolkits/AssistantToolkit.ts

@@ -1,47 +0,0 @@
-//
-// 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 * as Record from 'effect/Record';
-import * as Schema from 'effect/Schema';
-
-import { AiContextService, ArtifactId } from '@dxos/assistant';
-import { Ref } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { trim } from '@dxos/util';
-
-export const AssistantToolkit = 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 const tools = Record.keys(AssistantToolkit.tools);
-
-export const layer = () =>
-  AssistantToolkit.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

@@ -1,231 +0,0 @@
-//
-// 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 { ArtifactId } from '@dxos/assistant';
-import { DXN, Obj, Relation, Tag, Type } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { trim } from '@dxos/util';
-
-export const SystemToolkit = 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,
-    dependencies: [DatabaseService],
-  }),
-
-  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,
-    dependencies: [DatabaseService],
-  }),
-
-  //
-  // 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,
-    dependencies: [DatabaseService],
-  }),
-
-  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,
-    dependencies: [DatabaseService],
-  }),
-
-  //
-  // 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,
-    dependencies: [DatabaseService],
-  }),
-
-  //
-  // 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,
-    dependencies: [DatabaseService],
-  }),
-
-  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,
-    dependencies: [DatabaseService],
-  }),
-);
-
-export const tools = Record.keys(SystemToolkit.tools);
-
-export const layer = (): Layer.Layer<Tool.Handler<any>, never, never> =>
-  SystemToolkit.toLayer({
-    'schema-list': Effect.fnUntraced(function* () {
-      const { db } = yield* DatabaseService;
-      const schema = yield* Effect.promise(() => db.schemaRegistry.query({ location: ['database', 'runtime'] }).run());
-
-      return schema.map((schema) => {
-        const meta = Type.getMeta(schema);
-        return {
-          typename: Type.getTypename(schema),
-          jsonSchema: Type.toJsonSchema(schema),
-          kind: meta?.sourceSchema ? 'relation' : 'record',
-        };
-      });
-    }),
-
-    'schema-add': Effect.fnUntraced(function* ({ name, typename, jsonSchema }) {
-      const { db } = yield* DatabaseService;
-
-      yield* Effect.promise(() =>
-        db.schemaRegistry.register([
-          {
-            typename,
-            version: '0.1.0',
-            jsonSchema,
-            name,
-          },
-        ]),
-      );
-    }),
-
-    'object-create': Effect.fnUntraced(function* ({ typename, data }) {
-      const { db } = yield* DatabaseService;
-      const schema = yield* Effect.promise(() =>
-        db.schemaRegistry.query({ typename, location: ['database', 'runtime'] }).first(),
-      );
-
-      // TODO(dmaretskyi): How to add object to a collection?
-      const object = db.add(Obj.make(schema, data));
-      return object;
-    }),
-
-    'object-remove': Effect.fnUntraced(function* ({ id }) {
-      const { db } = yield* DatabaseService;
-      const object = yield* DatabaseService.resolve(DXN.parse(id));
-      db.remove(object);
-      return object;
-    }),
-
-    'relation-create': Effect.fnUntraced(function* ({ typename, source, target, data }) {
-      const { db } = yield* DatabaseService;
-      const schema = yield* Effect.promise(() =>
-        db.schemaRegistry.query({ typename, location: ['database', 'runtime'] }).first(),
-      );
-
-      const sourceObj = yield* DatabaseService.resolve(DXN.parse(source));
-      const targetObj = yield* DatabaseService.resolve(DXN.parse(target));
-      const relation = db.add(
-        Relation.make(schema, {
-          [Relation.Source]: sourceObj,
-          [Relation.Target]: targetObj,
-          ...data,
-        }),
-      );
-      return relation;
-    }),
-
-    'tag-add': Effect.fnUntraced(function* ({ tagId, objectId }) {
-      const object = yield* DatabaseService.resolve(DXN.parse(objectId));
-      Obj.addTag(object, DXN.parse(tagId).toString());
-      return object;
-    }),
-
-    'tag-remove': Effect.fnUntraced(function* ({ tagId, objectId }) {
-      const object = yield* DatabaseService.resolve(DXN.parse(objectId));
-      Obj.removeTag(object, DXN.parse(tagId).toString());
-      return object;
-    }),
-  });