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

package/src/{functions/research → crud}/graph.ts

@@ -11,28 +11,23 @@ import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { Obj, type Relation } from '@dxos/echo';
-import { Filter, Query } from '@dxos/echo';
+import { Entity, Filter, Obj, Query, Type } from '@dxos/echo';
+import { Database } from '@dxos/echo';
 import {
-  EntityKind,
-  ObjectId,
   ReferenceAnnotationId,
   RelationSourceDXNId,
   RelationSourceId,
   RelationTargetDXNId,
   RelationTargetId,
-  create,
-  getEntityKind,
-  getSchemaDXN,
-  getSchemaTypename,
+  createObject,
   getTypeAnnotation,
   getTypeIdentifierAnnotation,
 } from '@dxos/echo/internal';
-import { type EchoDatabase, type Queue } from '@dxos/echo-db';
+import { type Queue } from '@dxos/echo-db';
 import { isEncodedReference } from '@dxos/echo-protocol';
 import { mapAst } from '@dxos/effect';
-import { ContextQueueService, DatabaseService } from '@dxos/functions';
-import { DXN } from '@dxos/keys';
+import { ContextQueueService } from '@dxos/functions';
+import { DXN, ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { deepMapValues, isNonNullable, trim } from '@dxos/util';
 
@@ -45,7 +40,7 @@ export const Subgraph = Schema.Struct({
 export interface Subgraph extends Schema.Schema.Type<typeof Subgraph> {}
 
 export type RelatedSchema = {
-  schema: Schema.Schema.AnyNoContext;
+  schema: Type.Entity.Any;
   kind: 'reference' | 'relation';
 };
 
@@ -56,17 +51,14 @@ export type RelatedSchema = {
  * @param schema
  * @returns
  */
-export const findRelatedSchema = async (
-  db: EchoDatabase,
-  anchor: Schema.Schema.AnyNoContext,
-): Promise<RelatedSchema[]> => {
+export const findRelatedSchema = async (db: Database.Database, anchor: Type.Entity.Any): Promise<RelatedSchema[]> => {
   // TODO(dmaretskyi): Query stored schemas.
-  const allSchemas = [...db.graph.schemaRegistry.schemas];
+  const allSchemas = await db.graph.schemaRegistry.query().run();
 
   // TODO(dmaretskyi): Also do references.
   return allSchemas
     .filter((schema) => {
-      if (getTypeAnnotation(schema)?.kind !== EntityKind.Relation) {
+      if (getTypeAnnotation(schema)?.kind !== Entity.Kind.Relation) {
         return false;
       }
 
@@ -77,8 +69,8 @@ export const findRelatedSchema = async (
     })
     .map(
       (schema): RelatedSchema => ({
-        schema,
         kind: 'relation',
+        schema,
       }),
     );
 };
@@ -87,14 +79,14 @@ export const findRelatedSchema = async (
  * Non-strict DXN comparison.
  * Returns true if the DXN could be resolved to the schema.
  */
-const isSchemaAddressableByDxn = (schema: Schema.Schema.AnyNoContext, dxn: DXN): boolean => {
+const isSchemaAddressableByDxn = (schema: Type.Entity.Any, dxn: DXN): boolean => {
   if (getTypeIdentifierAnnotation(schema) === dxn.toString()) {
     return true;
   }
 
   const t = dxn.asTypeDXN();
   if (t) {
-    return t.type === getSchemaTypename(schema);
+    return t.type === Type.getTypename(schema);
   }
 
   return false;
@@ -114,13 +106,13 @@ export const LocalSearchToolkit = Toolkit.make(
     },
     success: Schema.Unknown,
     failure: Schema.Never,
-    dependencies: [DatabaseService],
+    dependencies: [Database.Service],
   }),
 );
 
 export const LocalSearchHandler = LocalSearchToolkit.toLayer({
   search_local_search: Effect.fn(function* ({ query }) {
-    const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
+    const objects = yield* Database.Service.runQuery(Query.select(Filter.text(query, { type: 'vector' })));
     const results = [...objects];
 
     const option = yield* Effect.serviceOption(ContextQueueService);
@@ -144,21 +136,21 @@ export const LocalSearchHandler = LocalSearchToolkit.toLayer({
 class GraphWriterSchema extends Context.Tag('@dxos/assistant/GraphWriterSchema')<
   GraphWriterSchema,
   {
-    schema: Schema.Schema.AnyNoContext[];
+    schema: Type.Entity.Any[];
   }
 >() {}
 
 /**
  * Forms typed objects that can be written to the graph database.
  */
-export const makeGraphWriterToolkit = ({ schema }: { schema: Schema.Schema.AnyNoContext[] }) => {
+export const makeGraphWriterToolkit = ({ schema }: { schema: Type.Entity.Any[] }) => {
   return Toolkit.make(
     Tool.make('graph_writer', {
       description: 'Write to the local graph database',
       parameters: createExtractionSchema(schema).fields,
       success: Schema.Unknown,
       failure: Schema.Never,
-      dependencies: [DatabaseService, ContextQueueService],
+      dependencies: [Database.Service, ContextQueueService],
     }).annotateContext(Context.make(GraphWriterSchema, { schema })),
   );
 };
@@ -178,10 +170,10 @@ export const makeGraphWriterHandler = (
 
   return toolkit.toLayer({
     graph_writer: Effect.fn(function* (input) {
-      const { db } = yield* DatabaseService;
+      const { db } = yield* Database.Service;
       const { queue } = yield* ContextQueueService;
       const data = yield* Effect.promise(() => sanitizeObjects(schema, input as any, db, queue));
-      yield* Effect.promise(() => queue.append(data as Obj.Any[]));
+      yield* Effect.promise(() => queue.append(data as Obj.Unknown[]));
 
       const dxns = data.map((obj) => Obj.getDXN(obj));
       onAppend?.(dxns);
@@ -193,31 +185,31 @@ export const makeGraphWriterHandler = (
 /**
  * Create a schema for structured data extraction.
  */
-export const createExtractionSchema = (types: Schema.Schema.AnyNoContext[]) => {
+export const createExtractionSchema = (types: Type.Entity.Any[]) => {
   return Schema.Struct({
     ...Object.fromEntries(
       types.map(preprocessSchema).map((schema, index) => [
         `objects_${getSanitizedSchemaName(types[index])}`,
         Schema.optional(Schema.Array(schema)).annotations({
-          description: `The objects of type: ${getSchemaDXN(types[index])?.asTypeDXN()!.type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option.getOrElse(() => ''))}`,
+          description: `The objects of type: ${Type.getDXN(types[index])?.asTypeDXN()!.type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option.getOrElse(() => ''))}`,
         }),
       ]),
     ),
   });
 };
 
-export const getSanitizedSchemaName = (schema: Schema.Schema.AnyNoContext) => {
-  return getSchemaDXN(schema)!
+export const getSanitizedSchemaName = (schema: Type.Entity.Any) => {
+  return Type.getDXN(schema)!
     .asTypeDXN()!
     .type.replaceAll(/[^a-zA-Z0-9]+/g, '_');
 };
 
 export const sanitizeObjects = async (
-  types: Schema.Schema.AnyNoContext[],
+  types: Type.Entity.Any[],
   data: Record<string, readonly unknown[]>,
-  db: EchoDatabase,
+  db: Database.Database,
   queue?: Queue,
-): Promise<Obj.Any[]> => {
+): Promise<Obj.Unknown[]> => {
   const entries = types
     .map(
       (type) =>
@@ -230,7 +222,7 @@ export const sanitizeObjects = async (
 
   const idMap = new Map<string, string>();
   const existingIds = new Set<ObjectId>();
-  const enitties = new Map<ObjectId, Obj.Any | Relation.Any>();
+  const enitties = new Map<ObjectId, Entity.Unknown>();
 
   const resolveId = (id: string): DXN | undefined => {
     if (ObjectId.isValid(id)) {
@@ -275,7 +267,7 @@ export const sanitizeObjects = async (
         return recurse(value);
       });
 
-      if (getEntityKind(entry.schema) === 'relation') {
+      if (Entity.getKind(entry.schema) === 'relation') {
         const sourceDxn = resolveId(data.source);
         if (!sourceDxn) {
           log.warn('source not found', { source: data.source });
@@ -298,7 +290,7 @@ export const sanitizeObjects = async (
     .filter((object) => !existingIds.has(object.data.id)); // TODO(dmaretskyi): This dissallows updating existing objects.
 
   // TODO(dmaretskyi): Use ref resolver.
-  const { objects: dbObjects } = await db.query(Query.select(Filter.ids(...existingIds))).run();
+  const dbObjects = await db.query(Query.select(Filter.id(...existingIds))).run();
   const queueObjects = (await queue?.getObjectsById([...existingIds])) ?? [];
   const objects = [...dbObjects, ...queueObjects].filter(isNonNullable);
 
@@ -332,7 +324,7 @@ export const sanitizeObjects = async (
       }
     }
     if (!skip) {
-      const obj = create(schema, data);
+      const obj = createObject(schema, data);
       enitties.set(obj.id, obj);
       return [obj];
     }
@@ -347,7 +339,7 @@ const SoftRef = Schema.Struct({
 });
 
 const preprocessSchema = (schema: Schema.Schema.AnyNoContext) => {
-  const isRelationSchema = getEntityKind(schema) === 'relation';
+  const isRelationSchema = Entity.getKind(schema) === 'relation';
 
   const go = (ast: SchemaAST.AST, visited = new Set<SchemaAST.AST>()): SchemaAST.AST => {
     if (visited.has(ast)) {

package/src/crud/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './graph';

package/src/experimental/feed.test.ts

@@ -13,9 +13,14 @@ import * as Redacted from 'effect/Redacted';
 import { AiService } from '@dxos/ai';
 import { AiServiceTestingPreset, EXA_API_KEY } from '@dxos/ai/testing';
 import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
-import { TestHelpers } from '@dxos/effect';
-import { ComputeEventLogger, CredentialsService, FunctionInvocationService, TracingService } from '@dxos/functions';
-import { TestDatabaseLayer, testStoragePath } from '@dxos/functions/testing';
+import { TestHelpers } from '@dxos/effect/testing';
+import { CredentialsService, FunctionInvocationService } from '@dxos/functions';
+import { TracingServiceExt } from '@dxos/functions-runtime';
+import {
+  FunctionInvocationServiceLayerTestMocked,
+  TestDatabaseLayer,
+  testStoragePath,
+} from '@dxos/functions-runtime/testing';
 
 import { Discord, Linear } from '../functions';
 
@@ -23,7 +28,6 @@ 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(
@@ -38,9 +42,8 @@ const TestLayer = Layer.mergeAll(
         { service: 'discord.com', apiKey: Config.redacted('DISCORD_TOKEN') },
         { service: 'linear.app', apiKey: Config.redacted('LINEAR_API_KEY') },
       ]),
-      FunctionInvocationService.layerTestMocked({ functions: [Linear.sync, Discord.fetch] }).pipe(
-        Layer.provideMerge(ComputeEventLogger.layerFromTracing),
-        Layer.provideMerge(TracingService.layerLogInfo()),
+      FunctionInvocationServiceLayerTestMocked({ functions: [Linear.sync, Discord.fetch] }).pipe(
+        Layer.provideMerge(TracingServiceExt.layerLogInfo()),
       ),
       FetchHttpClient.layer,
     ),
@@ -64,7 +67,7 @@ describe('Feed', { timeout: 600_000 }, () => {
 
         // const result = yield* AiSession.run({
         //   history: [
-        //     Obj.make(DataType.Message, {
+        //     Obj.make(Message.Message, {
         //       created: new Date().toISOString(),
         //       sender: { role: 'user' },
         //       blocks: messages
@@ -90,7 +93,7 @@ describe('Feed', { timeout: 600_000 }, () => {
 
         // const result = yield* AiSession.run({
         //   history: [
-        //     Obj.make(DataType.Message, {
+        //     Obj.make(Message.Message, {
         //       created: new Date().toISOString(),
         //       sender: { role: 'user' },
         //       blocks: [{ _tag: 'text', text: JSON.stringify(linearIssues) }],

package/src/functions/agent/prompt.ts

@@ -5,6 +5,7 @@
 import * as Array from 'effect/Array';
 import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
+import * as Match from 'effect/Match';
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 
@@ -12,7 +13,8 @@ import { AiService, ConsolePrinter, ModelName } from '@dxos/ai';
 import { AiSession, GenerationObserver, createToolkit } from '@dxos/assistant';
 import { Prompt, Template } from '@dxos/blueprints';
 import { Obj, Ref, Type } 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';
 
 const DEFAULT_MODEL: ModelName = '@anthropic/claude-opus-4-0';
@@ -32,50 +34,65 @@ export default defineFunction({
      * Input object or data.
      * References get auto-resolved.
      */
-    input: Schema.Record({ key: Schema.String, value: Schema.Any }),
+    input: Schema.Any.pipe(Schema.annotations({ title: 'Input' })),
   }),
   outputSchema: Schema.Any,
   handler: Effect.fnUntraced(function* ({ data }) {
     log.info('processing input', { input: data.input });
 
-    const input = { ...data.input };
-    for (const key of Object.keys(data.input)) {
-      const value = data.input[key];
-      if (Ref.isRef(value)) {
-        const object = yield* DatabaseService.load(value);
-        input[key] = Obj.toJSON(object);
-      } else {
-        input[key] = JSON.stringify(value);
-      }
-    }
+    // TODO(wittjosiah): Support templated object as input.
+    //   Currently the object templating only supports direct pass-through or strings.
+    // const input = { ...data.input };
+    // for (const key of Object.keys(data.input)) {
+    //   const value = data.input[key];
+    //   if (Ref.isRef(value)) {
+    //     const object = yield* Database.Service.load(value);
+    //     input[key] = Obj.toJSON(object);
+    //   } else {
+    //     input[key] = JSON.stringify(value);
+    //   }
+    // }
+    const input = yield* Match.value(data.input).pipe(
+      Match.when(
+        (value: any) => Ref.isRef(value),
+        Effect.fnUntraced(function* (ref) {
+          const object = yield* Database.Service.load(ref);
+          return Obj.toJSON(object as Obj.Unknown);
+        }),
+      ),
+      Match.orElse(() => Effect.succeed(data.input)),
+    );
 
-    yield* DatabaseService.flush({ indexes: true });
-    const prompt = yield* DatabaseService.load(data.prompt);
-    const systemPrompt = data.systemPrompt ? yield* DatabaseService.load(data.systemPrompt) : undefined;
+    yield* Database.Service.flush({ indexes: true });
+    const prompt = yield* Database.Service.load(data.prompt);
+    const systemPrompt = data.systemPrompt ? yield* Database.Service.load(data.systemPrompt) : undefined;
     yield* TracingService.emitStatus({ message: `Running ${prompt.id}` });
 
-    log.info('starting agent', { prompt: prompt.id, input: data.input });
+    log.info('starting agent', { prompt: prompt.id, input });
 
     const blueprints = yield* Function.pipe(
       prompt.blueprints,
       Array.appendAll(systemPrompt?.blueprints ?? []),
-      Effect.forEach(DatabaseService.loadOption),
+      Effect.forEach(Database.Service.loadOption),
       Effect.map(Array.filter(Option.isSome)),
       Effect.map(Array.map((option) => option.value)),
     );
+    const toolkit = yield* createToolkit({ blueprints });
+
     const objects = yield* Function.pipe(
       prompt.context,
       Array.appendAll(systemPrompt?.context ?? []),
-      Effect.forEach(DatabaseService.loadOption),
+      Effect.forEach(Database.Service.loadOption),
       Effect.map(Array.filter(Option.isSome)),
       Effect.map(Array.map((option) => option.value)),
     );
-    const toolkit = yield* createToolkit({ blueprints });
 
-    const promptInstructions = yield* DatabaseService.load(prompt.instructions.source);
+    const promptInstructions = yield* Database.Service.load(prompt.instructions.source);
     const promptText = Template.process(promptInstructions.content, input);
 
-    const systemInstructions = systemPrompt ? yield* DatabaseService.load(systemPrompt.instructions.source) : undefined;
+    const systemInstructions = systemPrompt
+      ? yield* Database.Service.load(systemPrompt.instructions.source)
+      : undefined;
     const systemText = systemInstructions ? Template.process(systemInstructions.content, {}) : undefined;
 
     const session = new AiSession();
@@ -84,7 +101,7 @@ export default defineFunction({
         prompt: promptText,
         system: systemText,
         blueprints,
-        objects: objects as Obj.Any[],
+        objects: objects as Obj.Unknown[],
         toolkit,
         observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'agent' })),
       })

package/src/functions/discord/fetch-messages.test.ts

@@ -12,9 +12,9 @@ import * as Layer from 'effect/Layer';
 import { AiService } from '@dxos/ai';
 import { AiServiceTestingPreset } from '@dxos/ai/testing';
 import { makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
-import { TestHelpers } from '@dxos/effect';
-import { ComputeEventLogger, CredentialsService, FunctionInvocationService, TracingService } from '@dxos/functions';
-import { TestDatabaseLayer } from '@dxos/functions/testing';
+import { TestHelpers } from '@dxos/effect/testing';
+import { CredentialsService, FunctionInvocationService, TracingService } from '@dxos/functions';
+import { FunctionInvocationServiceLayerTestMocked, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
 
 import { default as fetchMessages } from './fetch-messages';
 
@@ -22,7 +22,6 @@ 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(
@@ -30,9 +29,8 @@ const TestLayer = Layer.mergeAll(
       TestDatabaseLayer({}),
       CredentialsService.layerConfig([{ service: 'discord.com', apiKey: Config.redacted('DISCORD_TOKEN') }]),
       FetchHttpClient.layer,
-      FunctionInvocationService.layerTestMocked({ functions: [fetchMessages] }).pipe(
-        Layer.provideMerge(ComputeEventLogger.layerFromTracing),
-        Layer.provideMerge(TracingService.layerLogInfo()),
+      FunctionInvocationServiceLayerTestMocked({ functions: [fetchMessages] }).pipe(
+        Layer.provideMerge(TracingService.layerNoop),
       ),
     ),
   ),
@@ -53,6 +51,7 @@ describe('Feed', { timeout: 600_000 }, () => {
         console.log(messages);
       },
       Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
       TestHelpers.taggedTest('sync'),
     ),
   );

package/src/functions/discord/fetch-messages.ts

@@ -21,7 +21,7 @@ import * as Schema from 'effect/Schema';
 import { Obj } from '@dxos/echo';
 import { CredentialsService, TracingService, defineFunction } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Message } from '@dxos/types';
 
 // TODO(dmaretskyi): Extract.
 const TimeRange = class extends Schema.String.pipe(Schema.pattern(/\d+(s|m|h|d)/)).annotations({
@@ -71,7 +71,7 @@ const DEFAULT_IGNORE_USERNAMES = ['GitHub', 'Needle'];
 type Thread = {
   discordChannelId: string;
   name?: string;
-  messages: DataType.Message[];
+  messages: Message.Message[];
 };
 
 export default defineFunction({
@@ -133,7 +133,7 @@ export default defineFunction({
         throw new Error('no channels found');
       }
       for (const channel of channels) {
-        console.log(channel.id, 'name' in channel ? channel.name : undefined);
+        log.info('channel', { id: channel.id, name: 'name' in channel ? channel.name : undefined });
       }
 
       yield* TracingService.emitStatus({ message: `Will fetch from channels: ${channels.length}` });
@@ -141,9 +141,9 @@ export default defineFunction({
       const threads = yield* Effect.forEach(
         channels,
         Effect.fnUntraced(function* (channel) {
-          const allMessages: DataType.Message[] = [];
+          const allMessages: Message.Message[] = [];
 
-          let lastMessage: Option.Option<DataType.Message> = Option.none();
+          let lastMessage: Option.Option<Message.Message> = Option.none();
           while (true) {
             const { id: lastId = undefined } = Function.pipe(
               lastMessage,
@@ -188,7 +188,7 @@ export default defineFunction({
             messages: allMessages
               .filter((message) => !message.sender.name || !ignoreUsernames.includes(message.sender.name))
               .filter((message) =>
-                message.blocks.some((block) => block._tag === 'text' && block.text.trim().length > 0),
+                message.blocks.some((block: any) => block._tag === 'text' && block.text.trim().length > 0),
               ),
           } satisfies Thread;
         }),
@@ -222,8 +222,9 @@ const parseSnowflake = (snowflake: string): Date => {
   return new Date(Number((BigInt(snowflake) >> 22n) + discordEpoch));
 };
 
-const makeMessage = (message: MessageResponse): DataType.Message =>
-  Obj.make(DataType.Message, {
+// TODO(burdon): Move to @dxos/types.
+const makeMessage = (message: MessageResponse): Message.Message =>
+  Obj.make(Message.Message, {
     [Obj.Meta]: {
       keys: [
         { id: message.id, source: 'discord.com' },
@@ -243,8 +244,8 @@ const serializeThread = (thread: Thread): string => {
     .map(
       (message) =>
         `  ${message.sender.name}: ${message.blocks
-          .filter((block) => block._tag === 'text')
-          .map((block) => block.text)
+          .filter((block: any) => block._tag === 'text')
+          .map((block: any) => block.text)
           .join(' ')}`,
     )
     .join('\n')}\n</thread>`;

package/src/functions/document/index.ts

@@ -5,6 +5,7 @@
 import { default as read$ } from './read';
 import { default as update$ } from './update';
 
+/** @deprecated */
 export namespace Document {
   export const read = read$;
   export const update = update$;

package/src/functions/document/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,8 +23,8 @@ export default defineFunction({
     content: Schema.String,
   }),
   handler: Effect.fn(function* ({ data: { id } }) {
-    const doc = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Markdown.Document);
-    const { content } = yield* DatabaseService.load(doc.content);
+    const doc = yield* Database.Service.resolve(ArtifactId.toDXN(id), Markdown.Document);
+    const { content } = yield* Database.Service.load(doc.content);
     return { content };
   }),
 });

package/src/functions/document/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, Obj } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
 import { Markdown } from '@dxos/plugin-markdown/types';
 
 export default defineFunction({
@@ -23,8 +24,10 @@ export default defineFunction({
   }),
   outputSchema: Schema.Void,
   handler: Effect.fn(function* ({ data: { id, content } }) {
-    const doc = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Markdown.Document);
-    const text = yield* DatabaseService.load(doc.content);
-    text.content = content;
+    const doc = yield* Database.Service.resolve(ArtifactId.toDXN(id), Markdown.Document);
+    const text = yield* Database.Service.load(doc.content);
+    Obj.change(text, (t) => {
+      t.content = content;
+    });
   }),
 });