@dxos/assistant-toolkit 0.8.4-main.2c6827d → 0.8.4-main.3c1ae3b

package/src/functions/linear/sync-issues.ts

@@ -10,7 +10,8 @@ import * as Function from 'effect/Function';
 import * as Schema from 'effect/Schema';
 
 import { Filter, Obj, Query, Ref, type Type } from '@dxos/echo';
-import { DatabaseService, defineFunction, withAuthorization } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { defineFunction, withAuthorization } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { Person, Project, Task } from '@dxos/types';
 
@@ -35,7 +36,7 @@ query Issues($teamId: String!, $after: DateTimeOrDuration!) {
             updatedAt
             description
             assignee { id, name }
-            state { 
+            state {
                 name
             }
             project {
@@ -114,8 +115,8 @@ export default defineFunction({
 const getLatestUpdateTimestamp: (
   teamId: string,
   dataType: Type.Obj.Any,
-) => Effect.Effect<string, never, DatabaseService> = Effect.fnUntraced(function* (teamId, dataType) {
-  const { objects: existingTasks } = yield* DatabaseService.runQuery(
+) => Effect.Effect<string, never, Database.Service> = Effect.fnUntraced(function* (teamId, dataType) {
+  const existingTasks = yield* Database.Service.runQuery(
     Query.type(dataType).select(Filter.foreignKeys(dataType, [{ source: LINEAR_TEAM_ID_KEY, id: teamId }])),
   );
   return Function.pipe(

package/src/functions/research/document-create.ts

@@ -7,7 +7,8 @@ import * as Schema from 'effect/Schema';
 
 import { ArtifactId } from '@dxos/assistant';
 import { Obj, Relation } from '@dxos/echo';
-import { DatabaseService, TracingService, defineFunction } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { TracingService, defineFunction } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { Markdown } from '@dxos/plugin-markdown/types';
 import { HasSubject } from '@dxos/types';
@@ -42,14 +43,14 @@ export default defineFunction({
     log.info('Creating research document', { subject, name, content });
 
     // TODO(burdon): Auto flush before and after calling function?
-    yield* DatabaseService.flush({ indexes: true });
+    yield* Database.Service.flush({ indexes: true });
     yield* TracingService.emitStatus({ message: 'Creating research document...' });
 
     // TODO(burdon): Type check.
-    const target = (yield* DatabaseService.resolve(ArtifactId.toDXN(subject))) as Obj.Any;
+    const target = (yield* Database.Service.resolve(ArtifactId.toDXN(subject))) as Obj.Any;
 
     // Create document.
-    const object = yield* DatabaseService.add(
+    const object = yield* Database.Service.add(
       Markdown.make({
         name,
         content,
@@ -57,7 +58,7 @@ export default defineFunction({
     );
 
     // Create relation.
-    yield* DatabaseService.add(
+    yield* Database.Service.add(
       Relation.make(HasSubject.HasSubject, {
         [Relation.Source]: object,
         [Relation.Target]: target,
@@ -65,7 +66,7 @@ export default defineFunction({
       }),
     );
 
-    yield* DatabaseService.flush({ indexes: true });
+    yield* Database.Service.flush({ indexes: true });
     log.info('Created research document', { subject, object });
 
     return {

package/src/functions/research/research-graph.ts

@@ -7,8 +7,10 @@ import * as Layer from 'effect/Layer';
 import * as Schema from 'effect/Schema';
 
 import { Obj, Query, Ref, Type } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { SystemTypeAnnotation } from '@dxos/echo/internal';
 import { Queue } from '@dxos/echo-db';
-import { ContextQueueService, DatabaseService, QueueService } from '@dxos/functions';
+import { ContextQueueService, QueueService } from '@dxos/functions';
 
 /**
  * Container for a set of ephemeral research results.
@@ -20,28 +22,28 @@ export const ResearchGraph = Schema.Struct({
     typename: 'dxos.org/type/ResearchGraph',
     version: '0.1.0',
   }),
+  SystemTypeAnnotation.set(true),
 );
 
 export interface ResearchGraph extends Schema.Schema.Type<typeof ResearchGraph> {}
 
-export const queryResearchGraph: () => Effect.Effect<ResearchGraph | undefined, never, DatabaseService> = Effect.fn(
+export const queryResearchGraph: () => Effect.Effect<ResearchGraph | undefined, never, Database.Service> = Effect.fn(
   'queryResearchGraph',
 )(function* () {
-  const { objects } = yield* DatabaseService.runQuery(Query.type(ResearchGraph));
+  const objects = yield* Database.Service.runQuery(Query.type(ResearchGraph));
   return objects.at(0);
 });
 
-export const createResearchGraph: () => Effect.Effect<ResearchGraph, never, DatabaseService | QueueService> = Effect.fn(
-  'createResearchGraph',
-)(function* () {
-  const queue = yield* QueueService.createQueue();
-  return yield* DatabaseService.add(Obj.make(ResearchGraph, { queue: Ref.fromDXN(queue.dxn) }));
-});
+export const createResearchGraph: () => Effect.Effect<ResearchGraph, never, Database.Service | QueueService> =
+  Effect.fn('createResearchGraph')(function* () {
+    const queue = yield* QueueService.createQueue();
+    return yield* Database.Service.add(Obj.make(ResearchGraph, { queue: Ref.fromDXN(queue.dxn) }));
+  });
 
 export const contextQueueLayerFromResearchGraph = Layer.unwrapEffect(
   Effect.gen(function* () {
     const researchGraph = (yield* queryResearchGraph()) ?? (yield* createResearchGraph());
-    const researchQueue = yield* DatabaseService.load(researchGraph.queue);
+    const researchQueue = yield* Database.Service.load(researchGraph.queue);
     return ContextQueueService.layer(researchQueue);
   }),
 );

package/src/functions/research/research.test.ts

@@ -8,8 +8,8 @@ import { describe, 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 { AiService, ConsolePrinter } from '@dxos/ai';
+import { MemoizedAiService, TestAiService } from '@dxos/ai/testing';
 import {
   AiConversation,
   type ContextBinding,
@@ -19,14 +19,10 @@ import {
 } from '@dxos/assistant';
 import { Blueprint } from '@dxos/blueprints';
 import { Filter, Obj, Query, Ref } from '@dxos/echo';
-import { TestHelpers, acquireReleaseResource } from '@dxos/effect';
-import {
-  CredentialsService,
-  DatabaseService,
-  FunctionInvocationService,
-  QueueService,
-  TracingService,
-} from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { TestHelpers } from '@dxos/effect/testing';
+import { CredentialsService, FunctionInvocationService, QueueService, TracingService } from '@dxos/functions';
 import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
 import { invariant } from '@dxos/invariant';
 import { ObjectId } from '@dxos/keys';
@@ -76,13 +72,13 @@ describe('Research', () => {
     'call a function to generate a research report',
     Effect.fnUntraced(
       function* (_) {
-        yield* DatabaseService.add(
+        yield* Database.Service.add(
           Obj.make(Organization.Organization, {
             name: 'BlueYard',
             website: 'https://blueyard.com',
           }),
         );
-        yield* DatabaseService.flush({ indexes: true });
+        yield* Database.Service.flush({ indexes: true });
         const result = yield* FunctionInvocationService.invokeFunction(research, {
           query: 'Founders and portfolio of BlueYard.',
         });
@@ -90,10 +86,10 @@ describe('Research', () => {
         console.log(inspect(result, { depth: null, colors: true }));
         console.log(JSON.stringify(result, null, 2));
 
-        yield* DatabaseService.flush({ indexes: true });
+        yield* Database.Service.flush({ indexes: true });
         const researchGraph = yield* queryResearchGraph();
         if (researchGraph) {
-          const data = yield* DatabaseService.load(researchGraph.queue).pipe(
+          const data = yield* Database.Service.load(researchGraph.queue).pipe(
             Effect.flatMap((queue) => Effect.promise(() => queue.queryObjects())),
           );
           console.log(inspect(data, { depth: null, colors: true }));
@@ -109,7 +105,7 @@ describe('Research', () => {
     'create and update research report',
     Effect.fnUntraced(
       function* (_) {
-        const organization = yield* DatabaseService.add(
+        const organization = yield* Database.Service.add(
           Obj.make(Organization.Organization, {
             name: 'BlueYard',
             website: 'https://blueyard.com',
@@ -119,9 +115,9 @@ describe('Research', () => {
         const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
         const conversation = yield* acquireReleaseResource(() => new AiConversation(queue));
 
-        yield* DatabaseService.flush({ indexes: true });
-        const researchBlueprint = yield* DatabaseService.add(Obj.clone(ResearchBlueprint));
-        const markdownBlueprint = yield* DatabaseService.add(Obj.clone(MarkdownBlueprint));
+        yield* Database.Service.flush({ indexes: true });
+        const researchBlueprint = yield* Database.Service.add(Obj.clone(ResearchBlueprint));
+        const markdownBlueprint = yield* Database.Service.add(Obj.clone(MarkdownBlueprint));
         yield* Effect.promise(() =>
           conversation.context.bind({
             blueprints: [Ref.make(researchBlueprint), Ref.make(markdownBlueprint)],
@@ -136,8 +132,8 @@ describe('Research', () => {
           prompt: `Create a research summary about ${organization.name}.`,
         });
         {
-          const { objects: docs } = yield* DatabaseService.runQuery(
-            Query.select(Filter.ids(organization.id)).targetOf(HasSubject.HasSubject).source(),
+          const docs = yield* Database.Service.runQuery(
+            Query.select(Filter.id(organization.id)).targetOf(HasSubject.HasSubject).source(),
           );
           if (docs.length !== 1) {
             throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => _.name)}`);
@@ -147,7 +143,7 @@ describe('Research', () => {
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* DatabaseService.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.Service.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
 
@@ -156,8 +152,8 @@ describe('Research', () => {
           prompt: 'Add a section about their portfolio.',
         });
         {
-          const { objects: docs } = yield* DatabaseService.runQuery(
-            Query.select(Filter.ids(organization.id)).targetOf(HasSubject.HasSubject).source(),
+          const docs = yield* Database.Service.runQuery(
+            Query.select(Filter.id(organization.id)).targetOf(HasSubject.HasSubject).source(),
           );
           if (docs.length !== 1) {
             throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => _.name)}`);
@@ -167,7 +163,7 @@ describe('Research', () => {
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* DatabaseService.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.Service.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
       },

package/src/functions/research/research.ts

@@ -22,7 +22,8 @@ import {
 } from '@dxos/assistant';
 import { Template } from '@dxos/blueprints';
 import { type DXN, Obj } from '@dxos/echo';
-import { DatabaseService, TracingService, defineFunction } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { TracingService, defineFunction } from '@dxos/functions';
 import { FunctionInvocationServiceLayerTestMocked } from '@dxos/functions-runtime/testing';
 import { type Message, Person } from '@dxos/types';
 import { trim } from '@dxos/util';
@@ -84,7 +85,7 @@ export default defineFunction({
   handler: Effect.fnUntraced(
     function* ({ data: { query, instructions, mockSearch = false, entityExtraction = false } }) {
       if (mockSearch) {
-        const mockPerson = yield* DatabaseService.add(
+        const mockPerson = yield* Database.Service.add(
           Obj.make(Person.Person, {
             preferredName: 'John Doe',
             emails: [{ value: 'john.doe@example.com' }],
@@ -101,7 +102,7 @@ export default defineFunction({
         };
       }
 
-      yield* DatabaseService.flush({ indexes: true });
+      yield* Database.Service.flush({ indexes: true });
       yield* TracingService.emitStatus({ message: 'Starting research...' });
 
       const NativeWebSearch = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
@@ -137,7 +138,7 @@ export default defineFunction({
         observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'research' })),
       });
 
-      const objects = yield* Effect.forEach(objectDXNs, (dxn) => DatabaseService.resolve(dxn)).pipe(
+      const objects = yield* Effect.forEach(objectDXNs, (dxn) => Database.Service.resolve(dxn)).pipe(
         Effect.map(Array.map((obj) => Obj.toJSON(obj))),
       );
 

package/src/functions/research/types.ts

@@ -9,7 +9,7 @@ import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson
 /**
  * Data types for research.
  */
-export const ResearchDataTypes: (Type.Obj.Any | Type.Relation.Any)[] = [
+export const ResearchDataTypes: Type.Entity.Any[] = [
   // Objects
   Event.Event,
   LegacyOrganization,

package/src/functions/tasks/read.ts

@@ -6,7 +6,8 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { ArtifactId } from '@dxos/assistant';
-import { DatabaseService, defineFunction } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
 import { Markdown } from '@dxos/plugin-markdown/types';
 
 export default defineFunction({
@@ -22,10 +23,10 @@ export default defineFunction({
     content: Schema.String,
   }),
   handler: Effect.fn(function* ({ data: { id } }) {
-    const doc = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Markdown.Document);
+    const doc = yield* Database.Service.resolve(ArtifactId.toDXN(id), Markdown.Document);
 
     // Return content with line numbers prefixed.
-    const { content } = yield* DatabaseService.load(doc.content);
+    const { content } = yield* Database.Service.load(doc.content);
     const lines = content.split('\n');
     const len = String(lines.length).length;
     const numbered = lines.map((line, i) => `${String(i + 1).padStart(len, ' ')}. ${line}`).join('\n');

package/src/functions/tasks/update.ts

@@ -6,7 +6,8 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { ArtifactId } from '@dxos/assistant';
-import { DatabaseService, defineFunction } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
 import { Markdown } from '@dxos/plugin-markdown/types';
 
 import { MarkdownTasks, type TaskOperation } from './task-list';
@@ -34,10 +35,10 @@ export default defineFunction({
     }),
   }),
   handler: Effect.fn(function* ({ data: { id, operations = [] } }) {
-    const doc = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Markdown.Document);
+    const doc = yield* Database.Service.resolve(ArtifactId.toDXN(id), Markdown.Document);
 
     // Create task manager and apply operations if provided.
-    const { content } = yield* DatabaseService.load(doc.content);
+    const { content } = yield* Database.Service.load(doc.content);
     const taskManager = new MarkdownTasks(content);
     if (operations.length > 0) {
       taskManager.applyOperations(operations as TaskOperation[]);

package/src/plugins.tsx

@@ -6,11 +6,11 @@ import * as Schema from 'effect/Schema';
 import React from 'react';
 
 import { type AnyCapability, Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { type Obj, Type } from '@dxos/echo';
+import { Format, type Obj, Type } from '@dxos/echo';
 import { JsonFilter } from '@dxos/react-ui-syntax-highlighter';
 
 export const MapSchema = Schema.Struct({
-  coordinates: Type.Format.GeoPoint,
+  coordinates: Format.GeoPoint,
 }).pipe(
   Type.Obj({
     typename: 'example.com/type/Map',
@@ -62,7 +62,7 @@ export const capabilities: AnyCapability[] = [
       id: 'plugin-default',
       role: 'card--extrinsic',
       position: 'fallback',
-      component: ({ role, data }) => <JsonFilter data={data} />,
+      component: ({ data }) => <JsonFilter data={data} />,
     }),
   ),
 ];

package/src/sync/sync.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Filter, Obj, Query, Ref } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
+import { Database } from '@dxos/echo';
 import { failedInvariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
@@ -20,7 +20,7 @@ import { log } from '@dxos/log';
 export const syncObjects: (
   objs: Obj.Any[],
   opts: { foreignKeyId: string },
-) => Effect.Effect<Obj.Any[], never, DatabaseService> = Effect.fn('syncObjects')(function* (objs, { foreignKeyId }) {
+) => Effect.Effect<Obj.Any[], never, Database.Service> = Effect.fn('syncObjects')(function* (objs, { foreignKeyId }) {
   return yield* Effect.forEach(
     objs,
     Effect.fnUntraced(function* (obj) {
@@ -39,9 +39,7 @@ export const syncObjects: (
 
       const schema = Obj.getSchema(obj) ?? failedInvariant('No schema.');
       const foreignId = Obj.getKeys(obj, foreignKeyId)[0]?.id ?? failedInvariant('No foreign key.');
-      const {
-        objects: [existing],
-      } = yield* DatabaseService.runQuery(
+      const [existing] = yield* Database.Service.runQuery(
         Query.select(Filter.foreignKeys(schema, [{ source: foreignKeyId, id: foreignId }])),
       );
       log('sync object', {
@@ -50,7 +48,7 @@ export const syncObjects: (
         existing: existing ? Obj.getDXN(existing) : undefined,
       });
       if (!existing) {
-        yield* DatabaseService.add(obj);
+        yield* Database.Service.add(obj);
         return obj;
       } else {
         copyObjectData(existing, obj);

package/src/toolkits/AssistantToolkit.test.ts

@@ -6,8 +6,8 @@ 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 { AiService, ConsolePrinter } from '@dxos/ai';
+import { MemoizedAiService, TestAiService } from '@dxos/ai/testing';
 import {
   AiConversation,
   type ContextBinding,
@@ -18,8 +18,10 @@ import {
 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 { Database } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { TestHelpers } from '@dxos/effect/testing';
+import { CredentialsService, 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';
@@ -60,13 +62,13 @@ describe('AssistantToolkit', () => {
     'can add to context',
     Effect.fnUntraced(
       function* (_) {
-        const { db } = yield* DatabaseService;
+        const { db } = yield* Database.Service;
         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(
+        const organization = yield* Database.Service.add(
           Obj.make(Organization.Organization, {
             name: 'Cyberdyne Systems',
             website: 'https://cyberdyne.com',

package/src/toolkits/AssistantToolkit.ts

@@ -10,7 +10,7 @@ import * as Schema from 'effect/Schema';
 
 import { AiContextService, ArtifactId } from '@dxos/assistant';
 import { Ref } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
+import { Database } from '@dxos/echo';
 import { trim } from '@dxos/util';
 
 export const AssistantToolkit = Toolkit.make(
@@ -25,7 +25,7 @@ export const AssistantToolkit = Toolkit.make(
     },
     success: Schema.Void,
     failure: Schema.Never,
-    dependencies: [AiContextService, DatabaseService],
+    dependencies: [AiContextService, Database.Service],
   }),
 );
 
@@ -35,7 +35,7 @@ export const layer = () =>
   AssistantToolkit.toLayer({
     'add-to-context': Effect.fnUntraced(function* ({ id }) {
       const { binder } = yield* AiContextService;
-      const { db } = yield* DatabaseService;
+      const { db } = yield* Database.Service;
       const ref = Ref.fromDXN(ArtifactId.toDXN(id, db.spaceId));
       yield* Effect.promise(() =>
         binder.bind({

package/src/toolkits/SystemToolkit.ts

@@ -11,7 +11,7 @@ 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 { Database } from '@dxos/echo';
 import { trim } from '@dxos/util';
 
 export const SystemToolkit = Toolkit.make(
@@ -30,7 +30,7 @@ export const SystemToolkit = Toolkit.make(
     // TODO(dmaretskyi): Effect returns ({ result, encodedResult })
     success: Schema.Any,
     failure: Schema.Never,
-    dependencies: [DatabaseService],
+    dependencies: [Database.Service],
   }),
 
   Tool.make('schema-add', {
@@ -46,7 +46,7 @@ export const SystemToolkit = Toolkit.make(
     },
     success: Schema.Any,
     failure: Schema.Never,
-    dependencies: [DatabaseService],
+    dependencies: [Database.Service],
   }),
 
   //
@@ -64,7 +64,7 @@ export const SystemToolkit = Toolkit.make(
     },
     success: Schema.Any,
     failure: Schema.Never,
-    dependencies: [DatabaseService],
+    dependencies: [Database.Service],
   }),
 
   Tool.make('object-remove', {
@@ -78,7 +78,7 @@ export const SystemToolkit = Toolkit.make(
     },
     success: Schema.Any,
     failure: Schema.Never,
-    dependencies: [DatabaseService],
+    dependencies: [Database.Service],
   }),
 
   //
@@ -104,7 +104,7 @@ export const SystemToolkit = Toolkit.make(
     },
     success: Schema.Any,
     failure: Schema.Never,
-    dependencies: [DatabaseService],
+    dependencies: [Database.Service],
   }),
 
   //
@@ -126,7 +126,7 @@ export const SystemToolkit = Toolkit.make(
     },
     success: Schema.Any,
     failure: Schema.Never,
-    dependencies: [DatabaseService],
+    dependencies: [Database.Service],
   }),
 
   Tool.make('tag-remove', {
@@ -144,7 +144,7 @@ export const SystemToolkit = Toolkit.make(
     },
     success: Schema.Any,
     failure: Schema.Never,
-    dependencies: [DatabaseService],
+    dependencies: [Database.Service],
   }),
 );
 
@@ -153,7 +153,7 @@ 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 { db } = yield* Database.Service;
       const schema = yield* Effect.promise(() => db.schemaRegistry.query({ location: ['database', 'runtime'] }).run());
 
       return schema.map((schema) => {
@@ -167,7 +167,7 @@ export const layer = (): Layer.Layer<Tool.Handler<any>, never, never> =>
     }),
 
     'schema-add': Effect.fnUntraced(function* ({ name, typename, jsonSchema }) {
-      const { db } = yield* DatabaseService;
+      const { db } = yield* Database.Service;
 
       yield* Effect.promise(() =>
         db.schemaRegistry.register([
@@ -182,7 +182,7 @@ export const layer = (): Layer.Layer<Tool.Handler<any>, never, never> =>
     }),
 
     'object-create': Effect.fnUntraced(function* ({ typename, data }) {
-      const { db } = yield* DatabaseService;
+      const { db } = yield* Database.Service;
       const schema = yield* Effect.promise(() =>
         db.schemaRegistry.query({ typename, location: ['database', 'runtime'] }).first(),
       );
@@ -193,20 +193,20 @@ export const layer = (): Layer.Layer<Tool.Handler<any>, never, never> =>
     }),
 
     'object-remove': Effect.fnUntraced(function* ({ id }) {
-      const { db } = yield* DatabaseService;
-      const object = yield* DatabaseService.resolve(DXN.parse(id));
+      const { db } = yield* Database.Service;
+      const object = yield* Database.Service.resolve(DXN.parse(id));
       db.remove(object);
       return object;
     }),
 
     'relation-create': Effect.fnUntraced(function* ({ typename, source, target, data }) {
-      const { db } = yield* DatabaseService;
+      const { db } = yield* Database.Service;
       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 sourceObj = yield* Database.Service.resolve(DXN.parse(source));
+      const targetObj = yield* Database.Service.resolve(DXN.parse(target));
       const relation = db.add(
         Relation.make(schema, {
           [Relation.Source]: sourceObj,
@@ -218,13 +218,13 @@ export const layer = (): Layer.Layer<Tool.Handler<any>, never, never> =>
     }),
 
     'tag-add': Effect.fnUntraced(function* ({ tagId, objectId }) {
-      const object = yield* DatabaseService.resolve(DXN.parse(objectId));
+      const object = yield* Database.Service.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));
+      const object = yield* Database.Service.resolve(DXN.parse(objectId));
       Obj.removeTag(object, DXN.parse(tagId).toString());
       return object;
     }),