@dxos/assistant-toolkit 0.8.4-main.72ec0f3 → 0.8.4-main.937b3ca

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,
@@ -18,19 +18,14 @@ import {
   makeToolResolverFromFunctions,
 } 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, Filter, Obj, Query, Ref } 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';
-import { MarkdownBlueprint, MarkdownFunction } from '@dxos/plugin-markdown/toolkit';
+import { MarkdownBlueprint } from '@dxos/plugin-markdown/blueprints';
 import { Markdown } from '@dxos/plugin-markdown/types';
 import { HasSubject, type Message, Organization } from '@dxos/types';
 
@@ -46,15 +41,12 @@ ObjectId.dangerouslyDisableRandomness();
 
 const TestLayer = Layer.mergeAll(
   AiService.model('@anthropic/claude-opus-4-0'),
-  makeToolResolverFromFunctions(
-    [research, createDocument, MarkdownFunction.create, MarkdownFunction.open, MarkdownFunction.update],
-    testToolkit,
-  ),
+  makeToolResolverFromFunctions([research, createDocument, ...MarkdownBlueprint.functions], testToolkit),
   makeToolExecutionServiceFromFunctions(testToolkit, testToolkit.toLayer({}) as any),
 ).pipe(
   Layer.provideMerge(
     FunctionInvocationServiceLayerTest({
-      functions: [research, createDocument, MarkdownFunction.create, MarkdownFunction.open, MarkdownFunction.update],
+      functions: [research, createDocument, ...MarkdownBlueprint.functions],
     }),
   ),
   Layer.provideMerge(
@@ -76,13 +68,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 +82,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 +101,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',
@@ -117,11 +109,11 @@ describe('Research', () => {
         );
 
         const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation(queue));
+        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.make()));
         yield* Effect.promise(() =>
           conversation.context.bind({
             blueprints: [Ref.make(researchBlueprint), Ref.make(markdownBlueprint)],
@@ -136,8 +128,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 +139,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 +148,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 +159,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

@@ -21,8 +21,9 @@ import {
   makeToolResolverFromFunctions,
 } from '@dxos/assistant';
 import { Template } from '@dxos/blueprints';
-import { type DXN, Obj } from '@dxos/echo';
-import { DatabaseService, TracingService, defineFunction } from '@dxos/functions';
+import { type DXN, Entity, Obj } from '@dxos/echo';
+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({}));
@@ -122,9 +123,7 @@ export default defineFunction({
         ) as any;
       }
 
-      const finishedToolkit = yield* createToolkit({
-        toolkit: toolkit as any,
-      }).pipe(Effect.provide(handlers));
+      const finishedToolkit = yield* createToolkit({ toolkit }).pipe(Effect.provide(handlers));
 
       const session = new AiSession();
       const result = yield* session.run({
@@ -137,8 +136,8 @@ export default defineFunction({
         observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'research' })),
       });
 
-      const objects = yield* Effect.forEach(objectDXNs, (dxn) => DatabaseService.resolve(dxn)).pipe(
-        Effect.map(Array.map((obj) => Obj.toJSON(obj))),
+      const objects = yield* Effect.forEach(objectDXNs, (dxn) => Database.Service.resolve(dxn)).pipe(
+        Effect.map(Array.map((obj) => Entity.toJSON(obj))),
       );
 
       return {

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/index.ts

@@ -4,7 +4,6 @@
 
 export * from './blueprints';
 export * from './functions';
-export * from './plugins';
 export * from './sync';
 export * from './crud';
 export * from './toolkits';

package/src/initiative/Initiative.ts

@@ -0,0 +1,99 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { AiContextBinder, type ContextBinding } from '@dxos/assistant';
+import { Blueprint, Template } from '@dxos/blueprints';
+import { Database, Obj, Ref } from '@dxos/echo';
+import { QueueService } from '@dxos/functions';
+import { Text } from '@dxos/schema';
+import type { Message } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+import { agent, getContext, update } from './functions';
+import { Initiative, PLAN_ARTIFACT_NAME, SPEC_ARTIFACT_NAME } from './InitiativeSchema';
+
+export { Initiative, PLAN_ARTIFACT_NAME, SPEC_ARTIFACT_NAME } from './InitiativeSchema';
+export type { Initiative as InitiativeType } from './InitiativeSchema';
+
+export const make = (
+  props: Omit<Obj.MakeProps<typeof Initiative>, 'artifacts' | 'chat'> &
+    Partial<Pick<Obj.MakeProps<typeof Initiative>, 'artifacts'>> & {
+      spec: string;
+      plan?: string;
+      blueprints?: Ref.Ref<Blueprint.Blueprint>[];
+      contextObjects?: Ref.Ref<Obj.Any>[];
+    },
+): Effect.Effect<Initiative, never, QueueService | Database.Service> =>
+  Effect.gen(function* () {
+    const initiative = Obj.make(Initiative, {
+      ...props,
+      artifacts: [
+        {
+          name: SPEC_ARTIFACT_NAME,
+          data: Ref.make(Text.make(props.spec)),
+        },
+        {
+          name: PLAN_ARTIFACT_NAME,
+          data: Ref.make(Text.make(props.plan ?? '')),
+        },
+        ...(props.artifacts ?? []),
+      ],
+    });
+    yield* Database.Service.add(initiative);
+    const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
+    const contextBinder = new AiContextBinder({ queue });
+    const initiativeBlueprint = yield* Database.Service.add(Obj.clone(InitiativeBlueprint, { deep: true }));
+    yield* Effect.promise(() =>
+      contextBinder.bind({
+        blueprints: [Ref.make(initiativeBlueprint), ...(props.blueprints ?? [])],
+        objects: [Ref.make(initiative), ...(props.contextObjects ?? [])],
+      }),
+    );
+    Obj.change(initiative, (initiative) => {
+      initiative.chat = Ref.fromDXN(queue.dxn);
+    });
+
+    return initiative;
+  });
+
+export const functions = [getContext, update, agent];
+
+export const InitiativeBlueprint = Blueprint.make({
+  key: 'dxos.org/blueprint/initiative',
+  name: 'Initiative blueprint',
+  instructions: Template.make({
+    source: trim`
+      You work on an initiative. Each initiative has a spec - the goal of the initiative.
+      The initiative plan shows the current progress of the initiative.
+      Initiative has an number of associated artifacts you can read/write.
+      Spec and plan are also artifacts.
+      You can edit them if necessary.
+      
+      {{#with initiative}}
+        Initiative spec:
+          {{spec.dxn}}
+          {{spec.content}}
+
+        Initiative plan:
+          {{plan.dxn}}
+          {{plan.content}}
+
+        All artifacts:
+        {{#each artifacts}}
+          {{name}}: {{type}} {{dxn}}
+        {{/each}}
+      {{/with}}
+    `,
+    inputs: [
+      {
+        name: 'initiative',
+        kind: 'function',
+        function: 'dxos.org/function/initiative/get-context',
+      },
+    ],
+  }),
+  tools: Blueprint.toolDefinitions({ functions: [update] }),
+});

package/src/initiative/InitiativeSchema.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Type } from '@dxos/echo';
+import { Queue } from '@dxos/echo-db';
+
+/**
+ * Initiative schema definition.
+ */
+export const Initiative = Schema.Struct({
+  name: Schema.String,
+  artifacts: Schema.Array(
+    Schema.Struct({
+      name: Schema.String,
+      data: Type.Ref(Type.Obj),
+    }),
+  ),
+
+  // TODO(dmaretskyi): Consider using chat type.
+  // TODO(dmaretskyi): Multiple chats.
+  chat: Schema.optional(Type.Ref(Queue)),
+
+  // TODO(dmaretskyi): Triggers & input queue.
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Initiative',
+    version: '0.1.0',
+  }),
+);
+export interface Initiative extends Schema.Schema.Type<typeof Initiative> {}
+
+export const SPEC_ARTIFACT_NAME = 'Spec';
+
+export const PLAN_ARTIFACT_NAME = 'Plan';

package/src/initiative/functions/agent.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AiContextService, AiConversation } from '@dxos/assistant';
+import { Database, Obj, Type } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { TriggerEvent, defineFunction } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+
+import * as Initiative from '../InitiativeSchema';
+
+export default defineFunction({
+  key: 'dxos.org/function/initiative/agent',
+  name: 'Initiative Agent',
+  description: 'Agentic worker that drives the initiative autonomously.',
+  inputSchema: Schema.Struct({
+    initiative: Schema.suspend(() => Type.Ref(Initiative.Initiative)),
+    prompt: Schema.optional(Schema.String),
+    event: Schema.optional(TriggerEvent.TriggerEvent),
+  }),
+  outputSchema: Schema.Void,
+  services: [AiContextService],
+  handler: Effect.fnUntraced(function* ({ data }) {
+    const initiative = yield* Database.Service.load(data.initiative);
+    invariant(Obj.instanceOf(Initiative.Initiative, initiative));
+    invariant(initiative.chat, 'Initiative has no chat.');
+    const chatQueue = yield* Database.Service.load(initiative.chat!);
+    invariant(chatQueue, 'Initiative chat queue not found.');
+    const conversation = yield* acquireReleaseResource(() => new AiConversation({ queue: chatQueue as any }));
+
+    const iniativesInContext = conversation.context.getObjects().filter(Obj.instanceOf(Initiative.Initiative));
+    if (iniativesInContext.length !== 1) {
+      throw new Error('There should be exactly one initiative in context. Got: ' + iniativesInContext.length);
+    }
+
+    if (!data.prompt && !data.event) {
+      throw new Error('Either prompt or event must be provided.');
+    }
+
+    let input = '';
+    if (data.prompt) {
+      input += `${data.prompt}\n\n`;
+    }
+    if (data.event) {
+      input += `<event>\n${JSON.stringify(data.event, null, 2)}\n</event>\n\n`;
+    }
+
+    yield* conversation.createRequest({
+      prompt: input,
+      // observer: GenerationObserver.fromPrinter(new ConsolePrinter()),
+    });
+  }, Effect.scoped) as any, // TODO(dmaretskyi): Services don't align -- need to refactor how functions are defined.
+});

package/src/initiative/functions/getContext.ts

@@ -0,0 +1,74 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AiContextService } from '@dxos/assistant';
+import { Database, Obj } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Text } from '@dxos/schema';
+
+import * as Initiative from '../InitiativeSchema';
+
+export default defineFunction({
+  key: 'dxos.org/function/initiative/get-context',
+  name: 'Get Initiative Context',
+  description: 'Get the context of an initiative.',
+  inputSchema: Schema.Struct({}),
+  outputSchema: Schema.Struct({
+    spec: Schema.Struct({
+      dxn: Schema.String,
+      content: Schema.String,
+    }),
+    plan: Schema.Struct({
+      dxn: Schema.String,
+      content: Schema.String,
+    }),
+    artifacts: Schema.Array(
+      Schema.Struct({
+        name: Schema.String,
+        type: Schema.String,
+        dxn: Schema.String,
+      }),
+    ),
+  }),
+  services: [AiContextService],
+  handler: Effect.fnUntraced(function* ({ data }) {
+    const { binder } = yield* AiContextService;
+
+    const initiative = binder
+      .getObjects()
+      .filter((_) => Obj.instanceOf(Initiative.Initiative, _))
+      .at(0);
+    if (!initiative) {
+      throw new Error('No initiative in context.');
+    }
+
+    const spec = initiative.artifacts.find((artifact) => artifact.name === Initiative.SPEC_ARTIFACT_NAME);
+    const plan = initiative.artifacts.find((artifact) => artifact.name === Initiative.PLAN_ARTIFACT_NAME);
+    const specObj = !spec ? undefined : yield* Database.Service.resolve(spec.data, Text.Text);
+    const planObj = !plan ? undefined : yield* Database.Service.resolve(plan.data, Text.Text);
+
+    return {
+      spec: {
+        dxn: spec?.data.dxn.toString(),
+        content: specObj?.content ?? 'No spec found.',
+      },
+      plan: {
+        dxn: plan?.data.dxn.toString(),
+        content: planObj?.content ?? 'No plan found.',
+      },
+      artifacts: yield* Effect.forEach(initiative.artifacts, (artifact) =>
+        Effect.gen(function* () {
+          return {
+            name: artifact.name,
+            type: Obj.getTypename(yield* Database.Service.load(artifact.data)),
+            dxn: artifact.data.dxn.toString(),
+          };
+        }),
+      ),
+    };
+  }) as any, // TODO(dmaretskyi): Services don't align -- need to refactor how functions are defined.
+});

package/src/initiative/functions/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { default as getContext } from './getContext';
+export { default as update } from './update';
+export { default as agent } from './agent';

package/src/initiative/functions/update.ts

@@ -0,0 +1,63 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AiContextService } from '@dxos/assistant';
+import { Database, Obj, Ref } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Text } from '@dxos/schema';
+
+import * as Initiative from '../InitiativeSchema';
+
+export default defineFunction({
+  key: 'dxos.org/function/initiative/update',
+  name: 'Create or update artifact',
+  description: 'Updates the text artifact to have new content.',
+  inputSchema: Schema.Struct({
+    name: Schema.String.annotations({
+      description: 'The name of the artifact to update.',
+    }),
+    content: Schema.String.annotations({
+      description: 'The new content of the artifact.',
+    }),
+    create: Schema.optional(Schema.Boolean).annotations({
+      description: 'Whether to create the artifact if it does not exist.',
+    }),
+  }),
+  outputSchema: Schema.Void,
+  services: [AiContextService],
+  handler: Effect.fnUntraced(function* ({ data }) {
+    const { binder } = yield* AiContextService;
+
+    const initiative = binder
+      .getObjects()
+      .filter((_) => Obj.instanceOf(Initiative.Initiative, _))
+      .at(0);
+    if (!initiative) {
+      throw new Error('No initiative in context.');
+    }
+
+    const artifact = initiative.artifacts.find((artifact) => artifact.name === data.name);
+    if (!artifact) {
+      if (data.create) {
+        Obj.change(initiative, (initiative) => {
+          initiative.artifacts.push({
+            name: data.name,
+            data: Ref.make(Text.make(data.content)),
+          });
+        });
+        return;
+      } else {
+        throw new Error(`Artifact ${data.name} not found.`);
+      }
+    }
+
+    const artifactObj = yield* Database.Service.resolve(artifact.data, Text.Text);
+    Obj.change(artifactObj, (artifactObj) => {
+      artifactObj.content = data.content;
+    });
+  }) as any, // TODO(dmaretskyi): Services don't align -- need to refactor how functions are defined.
+});

package/src/initiative/index.ts

@@ -0,0 +1,3 @@
+//
+// Copyright 2026 DXOS.org
+//