@dxos/assistant-toolkit 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

package/src/functions/entity-extraction/entity-extraction.test.ts

@@ -6,22 +6,17 @@ import { describe, expect, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { AiService, MemoizedAiService } from '@dxos/ai';
-import { AiServiceTestingPreset } from '@dxos/ai/testing';
+import { AiService } from '@dxos/ai';
+import { MemoizedAiService, TestAiService } from '@dxos/ai/testing';
 import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
 import { Blueprint } from '@dxos/blueprints';
 import { Obj } from '@dxos/echo';
-import { TestHelpers } from '@dxos/effect';
-import {
-  ComputeEventLogger,
-  CredentialsService,
-  DatabaseService,
-  FunctionInvocationService,
-  TracingService,
-} from '@dxos/functions';
-import { TestDatabaseLayer } from '@dxos/functions/testing';
-import { ObjectId, PublicKey } from '@dxos/keys';
-import { DataType } from '@dxos/schema';
+import { Database } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { CredentialsService, FunctionInvocationService, 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 { testToolkit } from '../../blueprints/testing';
 import { ResearchGraph } from '../research';
@@ -34,17 +29,15 @@ const TestLayer = Layer.mergeAll(
   AiService.model('@anthropic/claude-opus-4-0'),
   makeToolResolverFromFunctions([], testToolkit),
   makeToolExecutionServiceFromFunctions(testToolkit, testToolkit.toLayer({}) as any),
-  ComputeEventLogger.layerFromTracing,
 ).pipe(
-  Layer.provideMerge(FunctionInvocationService.layerTest({ functions: [entityExtraction] })),
+  Layer.provideMerge(FunctionInvocationServiceLayerTest({ functions: [entityExtraction] })),
   Layer.provideMerge(
     Layer.mergeAll(
-      MemoizedAiService.layerTest().pipe(Layer.provide(AiServiceTestingPreset('direct'))),
+      TestAiService(),
       TestDatabaseLayer({
-        // TODO(dmaretskyi): define the constant space key in the test-builder.
-        spaceKey: PublicKey.from('665c420e0dec9aa36c2bedca567afb0778701920e346eaf83ab2bd3403859723'),
+        spaceKey: 'fixed',
         indexing: { vector: true },
-        types: [Blueprint.Blueprint, DataType.Message, DataType.Person, DataType.Organization, ResearchGraph],
+        types: [Blueprint.Blueprint, Message.Message, Person.Person, Organization.Organization, ResearchGraph],
       }),
       CredentialsService.configuredLayer([]),
       TracingService.layerNoop,
@@ -52,13 +45,13 @@ const TestLayer = Layer.mergeAll(
   ),
 );
 
-describe.skip('Entity extraction', () => {
+describe('Entity extraction', () => {
   it.effect(
     'call a function to generate a research report',
     Effect.fnUntraced(
       function* (_) {
-        const email = yield* DatabaseService.add(
-          Obj.make(DataType.Message, {
+        const email = yield* Database.Service.add(
+          Obj.make(Message.Message, {
             [Obj.Meta]: {
               tags: ['important'],
             },
@@ -83,7 +76,7 @@ describe.skip('Entity extraction', () => {
             ],
           }),
         );
-        yield* DatabaseService.flush({ indexes: true });
+        yield* Database.Service.flush({ indexes: true });
         const result = yield* FunctionInvocationService.invokeFunction(entityExtraction, {
           source: email,
         });

package/src/functions/entity-extraction/entity-extraction.ts

@@ -10,40 +10,50 @@ import * as Schema from 'effect/Schema';
 
 import { AiService } from '@dxos/ai';
 import { AiSession, makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
-import { Filter, Obj, Ref } from '@dxos/echo';
-import { DatabaseService, FunctionInvocationService, defineFunction } from '@dxos/functions';
+import { Filter, Obj, Ref, Type } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { FunctionInvocationServiceLayerTest } from '@dxos/functions-runtime/testing';
 import { type DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { type Actor, LegacyOrganization, Message, Organization, Person } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { contextQueueLayerFromResearchGraph, makeGraphWriterHandler, makeGraphWriterToolkit } from '../research';
+import { makeGraphWriterHandler, makeGraphWriterToolkit } from '../../crud';
+import { contextQueueLayerFromResearchGraph } from '../research';
 
 export default defineFunction({
   key: 'dxos.org/functions/entity-extraction',
   name: 'Entity Extraction',
   description: 'Extracts entities from emails and transcripts.',
   inputSchema: Schema.Struct({
-    source: DataType.Message.annotations({ description: 'Email or transcript to extract entities from.' }),
+    source: Message.Message.annotations({
+      description: 'Email or transcript to extract entities from.',
+    }),
 
     // TODO(dmaretskyi): Consider making this an array of blueprints instead.
-    instructions: Schema.optional(Schema.String).annotations({ description: 'Instructions extraction process.' }),
+    instructions: Schema.optional(Schema.String).annotations({
+      description: 'Instructions extraction process.',
+    }),
   }),
   outputSchema: Schema.Struct({
     entities: Schema.optional(
-      Schema.Array(Obj.Any).annotations({
+      Schema.Array(Type.Obj).annotations({
         description: 'Extracted entities.',
       }),
     ),
   }),
   handler: Effect.fnUntraced(
-    function* ({ data: { source, instructions } }) {
-      const contact = yield* extractContact(source);
-      let organization: DataType.Organization | null = null;
+    function* ({ data: { source: message, instructions } }) {
+      const tags = Obj.getMeta(message)?.tags;
+      const contact = yield* extractContact(message.sender, tags);
+      let organization: Organization.Organization | null = null;
 
       if (contact && !contact.organization) {
         const created: DXN[] = [];
-        const GraphWriterToolkit = makeGraphWriterToolkit({ schema: [DataType.LegacyOrganization] }).pipe();
+        const GraphWriterToolkit = makeGraphWriterToolkit({
+          schema: [LegacyOrganization],
+        }).pipe();
         const GraphWriterHandler = makeGraphWriterHandler(GraphWriterToolkit, {
           onAppend: (dxns) => created.push(...dxns),
         });
@@ -57,17 +67,22 @@ export default defineFunction({
             The extracted organization URL must match the sender's email domain.
             ${instructions ? '<user_intructions>' + instructions + '</user_intructions>' : ''},
           `,
-          prompt: JSON.stringify({ source, contact }),
+          prompt: JSON.stringify({ source: message, contact }),
           toolkit,
         });
 
         if (created.length > 1) {
           throw new Error('Multiple organizations created');
         } else if (created.length === 1) {
-          organization = yield* DatabaseService.resolve(created[0], DataType.Organization);
-          Obj.getMeta(organization).tags ??= [];
-          Obj.getMeta(organization).tags!.push(...(Obj.getMeta(source)?.tags ?? []));
-          contact.organization = Ref.make(organization);
+          organization = yield* Database.Service.resolve(created[0], Organization.Organization);
+          Obj.change(organization, (org) => {
+            const meta = Obj.getMeta(org);
+            meta.tags ??= [];
+            meta.tags.push(...(tags ?? []));
+          });
+          Obj.change(contact, (c) => {
+            c.organization = Ref.make(organization!);
+          });
         }
       }
 
@@ -83,22 +98,22 @@ export default defineFunction({
       ).pipe(
         Layer.provide(
           // TODO(dmaretskyi): This should be provided by environment.
-          Layer.mergeAll(FunctionInvocationService.layerTest()),
+          Layer.mergeAll(FunctionInvocationServiceLayerTest()),
         ),
       ),
     ),
   ),
 });
 
-const extractContact = Effect.fn('extractContact')(function* (message: DataType.Message) {
-  const name = message.sender.name;
-  const email = message.sender.email;
+const extractContact = Effect.fn('extractContact')(function* (actor: Actor.Actor, tags?: readonly string[]) {
+  const name = actor.name;
+  const email = actor.email;
   if (!email) {
-    log.warn('email is required for contact extraction', { sender: message.sender });
+    log.warn('email is required for contact extraction', { actor });
     return undefined;
   }
 
-  const { objects: existingContacts } = yield* DatabaseService.runQuery(Filter.type(DataType.Person));
+  const existingContacts = yield* Database.Service.runQuery(Filter.type(Person.Person));
 
   // Check for existing contact
   // TODO(dmaretskyi): Query filter DSL - https://linear.app/dxos/issue/DX-541/filtercontains-should-work-with-partial-objects
@@ -111,16 +126,16 @@ const extractContact = Effect.fn('extractContact')(function* (message: DataType.
     return existingContact;
   }
 
-  const newContact = Obj.make(DataType.Person, {
-    [Obj.Meta]: {
-      tags: Obj.getMeta(message)?.tags,
-    },
+  const newContact = Obj.make(Person.Person, {
+    ...(tags ? { [Obj.Meta]: { tags: [...tags] } } : {}),
     emails: [{ value: email }],
   });
-  yield* DatabaseService.add(newContact);
+  yield* Database.Service.add(newContact);
 
   if (name) {
-    newContact.fullName = name;
+    Obj.change(newContact, (c) => {
+      c.fullName = name;
+    });
   }
 
   const emailDomain = email.split('@')[1]?.toLowerCase();
@@ -131,7 +146,7 @@ const extractContact = Effect.fn('extractContact')(function* (message: DataType.
 
   log.info('extracted email domain', { emailDomain });
 
-  const { objects: existingOrganisations } = yield* DatabaseService.runQuery(Filter.type(DataType.Organization));
+  const existingOrganisations = yield* Database.Service.runQuery(Filter.type(Organization.Organization));
   const matchingOrg = existingOrganisations.find((org) => {
     if (org.website) {
       try {
@@ -147,7 +162,10 @@ const extractContact = Effect.fn('extractContact')(function* (message: DataType.
           emailDomain.endsWith(`.${websiteDomain}`)
         );
       } catch (e) {
-        log.warn('Error parsing website URL', { website: org.website, error: e });
+        log.warn('Error parsing website URL', {
+          website: org.website,
+          error: e,
+        });
         return false;
       }
     }
@@ -156,7 +174,9 @@ const extractContact = Effect.fn('extractContact')(function* (message: DataType.
 
   if (matchingOrg) {
     log.info('found matching organization', { organization: matchingOrg });
-    newContact.organization = Ref.make(matchingOrg);
+    Obj.change(newContact, (c) => {
+      c.organization = Ref.make(matchingOrg);
+    });
   }
 
   return newContact;

package/src/functions/exa/mock.ts

@@ -7,7 +7,7 @@ import * as Schema from 'effect/Schema';
 
 import { defineFunction } from '@dxos/functions';
 
-import { SEARCH_RESULTS } from '../../testing';
+import { SEARCH_RESULTS } from './data';
 
 export default defineFunction({
   key: 'dxos.org/function/exa-mock',

package/src/functions/github/fetch-prs.ts

@@ -6,7 +6,7 @@ import * as HttpClient from '@effect/platform/HttpClient';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { defineFunction, withAuthorization } from '@dxos/functions';
+import { CredentialsService, defineFunction, withAuthorization } from '@dxos/functions';
 
 export default defineFunction({
   key: 'dxos.org/function/github/fetch-prs',
@@ -21,7 +21,8 @@ export default defineFunction({
     }),
   }),
   handler: Effect.fnUntraced(function* ({ data }) {
-    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization({ service: 'github.com' })));
+    const credential = yield* CredentialsService.getCredential({ service: 'github.com' });
+    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
 
     const response = yield* client.get(`https://api.github.com/repos/${data.owner}/${data.repo}/pulls`);
     const json: any = yield* response.json;

package/src/functions/linear/linear.test.ts

@@ -13,16 +13,16 @@ import { AiService } from '@dxos/ai';
 import { AiServiceTestingPreset } from '@dxos/ai/testing';
 import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
 import { Obj, Query } from '@dxos/echo';
-import { TestHelpers } from '@dxos/effect';
+import { Database } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { CredentialsService, FunctionInvocationService } from '@dxos/functions';
+import { TracingServiceExt } from '@dxos/functions-runtime';
 import {
-  ComputeEventLogger,
-  CredentialsService,
-  DatabaseService,
-  FunctionInvocationService,
-  TracingService,
-} from '@dxos/functions';
-import { TestDatabaseLayer, testStoragePath } from '@dxos/functions/testing';
-import { DataType } from '@dxos/schema';
+  FunctionInvocationServiceLayerTestMocked,
+  TestDatabaseLayer,
+  testStoragePath,
+} from '@dxos/functions-runtime/testing';
+import { Person, Project, Task } from '@dxos/types';
 
 import { LINEAR_ID_KEY, default as fetchLinearIssues } from './sync-issues';
 
@@ -30,21 +30,19 @@ const TestLayer = Layer.mergeAll(
   AiService.model('@anthropic/claude-opus-4-0'),
   makeToolResolverFromFunctions([], Toolkit.make()),
   makeToolExecutionServiceFromFunctions(Toolkit.make() as any, Layer.empty as any),
-  ComputeEventLogger.layerFromTracing,
 ).pipe(
   Layer.provideMerge(
     Layer.mergeAll(
       AiServiceTestingPreset('direct'),
       TestDatabaseLayer({
         // indexing: { vector: true },
-        types: [DataType.Task, DataType.Person, DataType.Project],
+        types: [Task.Task, Person.Person, Project.Project],
         storagePath: testStoragePath({ name: 'feed-test-13' }),
       }),
       CredentialsService.layerConfig([{ service: 'linear.app', apiKey: Config.redacted('LINEAR_API_KEY') }]),
-      FunctionInvocationService.layerTestMocked({ functions: [fetchLinearIssues] }).pipe(
-        Layer.provideMerge(ComputeEventLogger.layerFromTracing),
-        Layer.provideMerge(TracingService.layerLogInfo()),
-      ),
+      FunctionInvocationServiceLayerTestMocked({
+        functions: [fetchLinearIssues],
+      }).pipe(Layer.provideMerge(TracingServiceExt.layerLogInfo())),
       FetchHttpClient.layer,
     ),
   ),
@@ -55,29 +53,29 @@ describe('Linear', { timeout: 600_000 }, () => {
     'sync',
     Effect.fnUntraced(
       function* (_) {
-        yield* DatabaseService.flush({ indexes: true });
+        yield* Database.Service.flush({ indexes: true });
 
         yield* FunctionInvocationService.invokeFunction(fetchLinearIssues, {
           team: '1127c63a-6f77-4725-9229-50f6cd47321c',
         });
 
-        const { objects: persons } = yield* DatabaseService.runQuery(Query.type(DataType.Person));
+        const persons = yield* Database.Service.runQuery(Query.type(Person.Person));
         console.log('people', {
           count: persons.length,
           people: persons.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
         });
-        const { objects: projects } = yield* DatabaseService.runQuery(Query.type(DataType.Project));
+        const projects = yield* Database.Service.runQuery(Query.type(Project.Project));
         console.log('projects', {
           count: projects.length,
           projects: projects.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
         });
-        const { objects: tasks } = yield* DatabaseService.runQuery(Query.type(DataType.Task));
+        const tasks = yield* Database.Service.runQuery(Query.type(Task.Task));
         console.log('tasks', {
           count: tasks.length,
           tasks: tasks.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
         });
 
-        yield* DatabaseService.flush({ indexes: true });
+        yield* Database.Service.flush({ indexes: true });
       },
       Effect.provide(TestLayer),
       TestHelpers.taggedTest('sync'),

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

@@ -10,9 +10,10 @@ 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 { CredentialsService, defineFunction, withAuthorization } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Person, Project, Task } from '@dxos/types';
 
 import { syncObjects } from '../../sync';
 import { graphqlRequestBody } from '../../util';
@@ -35,7 +36,7 @@ query Issues($teamId: String!, $after: DateTimeOrDuration!) {
             updatedAt
             description
             assignee { id, name }
-            state { 
+            state {
                 name
             }
             project {
@@ -84,10 +85,11 @@ export default defineFunction({
     }),
   }),
   handler: Effect.fnUntraced(function* ({ data }) {
-    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization({ service: 'linear.app' })));
+    const credential = yield* CredentialsService.getCredential({ service: 'linear.app' });
+    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
 
     // Get the timestamp that was previosly synced.
-    const after = yield* getLatestUpdateTimestamp(data.team, DataType.Task);
+    const after = yield* getLatestUpdateTimestamp(data.team, Task.Task);
     log.info('will fetch', { after });
 
     // Fetch the issues that have changed since the last sync.
@@ -114,8 +116,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(
@@ -126,8 +128,8 @@ const getLatestUpdateTimestamp: (
   );
 });
 
-const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }): DataType.Person =>
-  Obj.make(DataType.Person, {
+const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }): Person.Person =>
+  Obj.make(Person.Person, {
     [Obj.Meta]: {
       keys: [
         {
@@ -143,8 +145,8 @@ const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }):
     nickname: person.name,
   });
 
-const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): DataType.Task =>
-  Obj.make(DataType.Task, {
+const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Task.Task =>
+  Obj.make(Task.Task, {
     [Obj.Meta]: {
       keys: [
         {
@@ -170,7 +172,7 @@ const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Dat
     project: !issue.project
       ? undefined
       : Ref.make(
-          DataType.makeProject({
+          Project.make({
             [Obj.Meta]: {
               keys: [
                 {

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

@@ -0,0 +1,76 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { ArtifactId } from '@dxos/assistant';
+import { Obj, Relation } from '@dxos/echo';
+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';
+import { trim } from '@dxos/util';
+
+export default defineFunction({
+  key: 'dxos.org/function/research/document-create',
+  name: 'Create research document',
+  description: 'Creates a note summarizing the research.',
+  inputSchema: Schema.Struct({
+    subject: ArtifactId.annotations({
+      description: trim`
+        ID of the object (organization, contact, etc.) for which the research was performed. 
+      `,
+    }),
+    name: Schema.String.annotations({
+      description: 'Name of the document.',
+    }),
+    content: Schema.String.annotations({
+      description: trim`
+        Content of the note. 
+        Supports (and are prefered) references to research objects using @ syntax and <object> tags (refer to research blueprint instructions).
+      `,
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    document: ArtifactId.annotations({
+      description: 'DXN of the created document.',
+    }),
+  }),
+  handler: Effect.fnUntraced(function* ({ data: { subject, name, content } }) {
+    log.info('Creating research document', { subject, name, content });
+
+    // TODO(burdon): Auto flush before and after calling function?
+    yield* Database.Service.flush({ indexes: true });
+    yield* TracingService.emitStatus({ message: 'Creating research document...' });
+
+    // TODO(burdon): Type check.
+    const target = (yield* Database.Service.resolve(ArtifactId.toDXN(subject))) as Obj.Unknown;
+
+    // Create document.
+    const object = yield* Database.Service.add(
+      Markdown.make({
+        name,
+        content,
+      }),
+    );
+
+    // Create relation.
+    yield* Database.Service.add(
+      Relation.make(HasSubject.HasSubject, {
+        [Relation.Source]: object,
+        [Relation.Target]: target,
+        completedAt: new Date().toISOString(),
+      }),
+    );
+
+    yield* Database.Service.flush({ indexes: true });
+    log.info('Created research document', { subject, object });
+
+    return {
+      document: Obj.getDXN(object).toString(),
+    };
+  }),
+});

package/src/functions/research/index.ts

@@ -2,10 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { default as create$ } from './create-document';
+import { default as create$ } from './document-create';
 import { default as research$ } from './research';
 
-export * from './graph';
 export * from './research-graph';
 export * from './types';
 

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.
@@ -16,32 +18,32 @@ import { ContextQueueService, DatabaseService, QueueService } from '@dxos/functi
 export const ResearchGraph = Schema.Struct({
   queue: Type.Ref(Queue),
 }).pipe(
-  Type.Obj({
+  Type.object({
     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);
   }),
 );