@dxos/assistant-toolkit 0.8.4-main.21d9917

package/src/functions/tasks/update.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { ArtifactId } from '@dxos/assistant';
+import { Database } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Markdown } from '@dxos/plugin-markdown/types';
+
+import { MarkdownTasks, type TaskOperation } from './task-list';
+
+export default defineFunction({
+  key: 'dxos.org/function/markdown/update-tasks',
+  name: 'Update markdown',
+  description: 'Creates and updates tasks in markdown documents.',
+  inputSchema: Schema.Struct({
+    id: ArtifactId.annotations({
+      description: 'The ID of the document to update.',
+    }),
+    operations: Schema.optional(
+      Schema.Array(
+        Schema.Any.annotations({
+          description: 'Task operations to apply.',
+        }),
+      ),
+    ),
+  }),
+  outputSchema: Schema.Struct({
+    content: Schema.String,
+    numberedContent: Schema.String.annotations({
+      description: 'Content with line numbers for agent reference.',
+    }),
+  }),
+  handler: Effect.fn(function* ({ data: { id, operations = [] } }) {
+    const doc = yield* Database.Service.resolve(ArtifactId.toDXN(id), Markdown.Document);
+
+    // Create task manager and apply operations if provided.
+    const { content } = yield* Database.Service.load(doc.content);
+    const taskManager = new MarkdownTasks(content);
+    if (operations.length > 0) {
+      taskManager.applyOperations(operations as TaskOperation[]);
+      // TODO: Update the document content when database operations are fixed.
+    }
+
+    return {
+      content: taskManager.getRawContent(),
+      numberedContent: taskManager.getNumberedContent(),
+    };
+  }),
+});

package/src/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './blueprints';
+export * from './functions';
+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
+//