@dxos/assistant-toolkit 0.8.4-main.1068cf700f

package/src/functions/tasks/update.ts

@@ -0,0 +1,52 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Database, Type } 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({
+    doc: Type.Ref(Markdown.Document).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: { doc, operations = [] } }) {
+    const document = yield* Database.load(doc);
+
+    // Create task manager and apply operations if provided.
+    const { content } = yield* Database.load(document.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,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './blueprints';
+export * from './chat';
+export * from './crud';
+export * from './functions';
+export * as Initiative from './initiative';
+export * from './sync';
+export * from './toolkits';
+export * as Planning from './planning';

package/src/initiative/Initiative.ts

@@ -0,0 +1,61 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Type } from '@dxos/echo';
+import { Queue } from '@dxos/echo-db';
+import { QueueAnnotation, Text } from '@dxos/schema';
+
+import * as Chat from '../chat/Chat';
+
+import { Plan } from './plan';
+
+/**
+ * Initiative schema definition.
+ */
+export const Initiative = Schema.Struct({
+  name: Schema.String,
+
+  spec: Type.Ref(Text.Text),
+  plan: Type.Ref(Plan),
+
+  artifacts: Schema.Array(
+    Schema.Struct({
+      // TODO(dmaretskyi): Consider gettings names from the artifact itself using Obj.getLabel.
+      name: Schema.String,
+      data: Type.Ref(Type.Obj),
+    }),
+  ),
+
+  /**
+   * Incoming queue that the agent processes.
+   */
+  // NOTE: Named `queue` to conform to subscribable schema (see QueueAnnotation).
+  queue: Schema.optional(Type.Ref(Queue)),
+
+  // TODO(dmaretskyi): Multiple chats.
+  chat: Schema.optional(Type.Ref(Chat.Chat)),
+
+  /**
+   * Objects to subscribe to.
+   * References to objects with a a canonical queue property.
+   * Schema must have the QueueAnnotation.
+   */
+  // TODO(dmaretskyi): Turn into an array of objects when form-data
+  subscriptions: Schema.Array(Type.Ref(Type.Obj)),
+
+  useQualifyingAgent: Schema.optional(Schema.Boolean),
+
+  newChatOnEveryEvent: Schema.optional(Schema.Boolean),
+
+  // TODO(dmaretskyi): input queue?
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Initiative',
+    version: '0.1.0',
+  }),
+  QueueAnnotation.set(true),
+);
+export interface Initiative extends Schema.Schema.Type<typeof Initiative> {}

package/src/initiative/blueprint.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Blueprint, Template } from '@dxos/blueprints';
+import { trim } from '@dxos/util';
+
+import { addArtifact, agent, getContext, qualifier } from './functions';
+
+/**
+ * Get all initiative functions. This is a function to avoid circular dependency issues.
+ */
+export const getFunctions = () => [getContext, addArtifact, agent, qualifier];
+
+/**
+ * Creates the Initiative blueprint. This is a function to avoid circular dependency issues.
+ */
+export const makeBlueprint = () =>
+  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.
+
+        IMPORTANT: When create a new artifact, always add it to the initiative using the add-artifact function.
+        
+        {{#with initiative}}
+        <initiative id="{{id}}" name="{{name}}">
+          <spec>
+            {{spec}}
+          </spec>
+          <plan>
+            {{plan}}
+          </plan>
+
+          <artifacts>
+          {{#each artifacts}}
+            <artifact type="{{type}}" dxn="{{dxn}}">
+              {{name}}
+            </artifact>
+          {{/each}}
+          </artifacts>
+        </initiative>
+        {{/with}}
+      `,
+      inputs: [
+        {
+          name: 'initiative',
+          kind: 'function',
+          function: 'dxos.org/function/initiative/get-context',
+        },
+      ],
+    }),
+    tools: Blueprint.toolDefinitions({ functions: [addArtifact] }),
+  });

package/src/initiative/functions/addArtifact.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AiContextService } from '@dxos/assistant';
+import { Database, Obj, Type } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+
+import { getFromChatContext } from '../util';
+
+export default defineFunction({
+  key: 'dxos.org/function/initiative/add-artifact',
+  name: 'Add artifact',
+  description: 'Adds a new artifact.',
+  inputSchema: Schema.Struct({
+    name: Schema.String.annotations({
+      description: 'The name of the artifact to add.',
+    }),
+    artifact: Type.Ref(Type.Obj).annotations({
+      description: 'The artifact to add. Do NOT guess or try to generate the ID.',
+    }),
+  }),
+  services: [AiContextService],
+  handler: Effect.fnUntraced(function* ({ data }) {
+    if (!(yield* Database.load(data.artifact))) {
+      throw new Error('Artifact not found.');
+    }
+
+    const initiative = yield* getFromChatContext;
+
+    Obj.change(initiative, (initiative) => {
+      initiative.artifacts.push({
+        name: data.name,
+        data: data.artifact,
+      });
+    });
+  }, AiContextService.fixFunctionHandlerType),
+});

package/src/initiative/functions/agent.ts

@@ -0,0 +1,77 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+import { AiContextService, AiConversation, type ContextBinding } from '@dxos/assistant';
+import { Database, Obj, Type } from '@dxos/echo';
+import { type Queue } from '@dxos/echo-db';
+import { acquireReleaseResource } from '@dxos/effect';
+import { TriggerEvent, defineFunction } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { type Message } from '@dxos/types';
+
+import * as Initiative from '../Initiative';
+import { resetChatHistory } from '../util';
+
+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.load(data.initiative);
+      invariant(Obj.instanceOf(Initiative.Initiative, initiative));
+      invariant(initiative.chat, 'Initiative has no chat.');
+
+      if (initiative.newChatOnEveryEvent) {
+        yield* resetChatHistory(initiative);
+      }
+
+      const chatQueue = yield* initiative.chat.pipe(
+        Database.load,
+        Effect.flatMap((chat) => Database.load(chat.queue)),
+      );
+      invariant(chatQueue, 'Initiative chat queue not found.');
+      const conversation = yield* acquireReleaseResource(
+        () => new AiConversation({ queue: chatQueue as Queue<Message.Message | ContextBinding> }),
+      );
+
+      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,
+        })
+        .pipe(Effect.retry({ times: 2 }));
+    },
+    Effect.scoped,
+    Effect.provide(AiService.model('@anthropic/claude-sonnet-4-5')),
+    AiContextService.fixFunctionHandlerType,
+  ) as any,
+});

package/src/initiative/functions/getContext.ts

@@ -0,0 +1,54 @@
+//
+// 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 { formatPlan } from '../plan';
+import { getFromChatContext } from '../util';
+
+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({
+    id: Schema.String,
+    name: Schema.String,
+    spec: Schema.String,
+    plan: Schema.String,
+    artifacts: Schema.Array(
+      Schema.Struct({
+        name: Schema.String,
+        type: Schema.optional(Schema.String),
+        dxn: Schema.optional(Schema.String),
+      }),
+    ),
+  }),
+  services: [AiContextService],
+  handler: Effect.fnUntraced(function* ({ data: _data }) {
+    const initiative = yield* getFromChatContext;
+
+    return {
+      id: initiative.id,
+      name: initiative.name,
+      spec: yield* initiative.spec.pipe(Database.load).pipe(Effect.map((_) => _.content)),
+      plan: yield* initiative.plan?.pipe(Database.load).pipe(Effect.map(formatPlan)) ??
+        Effect.succeed('No plan found.'),
+      artifacts: yield* Effect.forEach(initiative.artifacts, (artifact) =>
+        Effect.gen(function* () {
+          return {
+            name: artifact.name,
+            type: Obj.getTypename(yield* Database.load(artifact.data)),
+            dxn: artifact.data.dxn.toString(),
+          };
+        }),
+      ),
+    };
+  }, AiContextService.fixFunctionHandlerType),
+});

package/src/initiative/functions/index.ts

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

package/src/initiative/functions/qualifier.ts

@@ -0,0 +1,98 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import * as Prompt from '@effect/ai/Prompt';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+import { Database, Obj, Ref, Type } from '@dxos/echo';
+import { TriggerEvent, defineFunction } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { trim } from '@dxos/util';
+
+import * as Initiative from '../Initiative';
+import { formatPlan } from '../plan';
+
+export default defineFunction({
+  key: 'dxos.org/function/initiative/qualifier',
+  name: 'Initiative Qualifier',
+  description:
+    'Qualifier that determines if the event is relevant to the initiative. Puts the data into the input queue of the initiative.',
+  inputSchema: Schema.Struct({
+    initiative: Schema.suspend(() => Type.Ref(Initiative.Initiative)),
+    event: TriggerEvent.TriggerEvent,
+  }),
+  outputSchema: Schema.Void,
+  services: [],
+  handler: Effect.fnUntraced(
+    function* ({ data }) {
+      const initiative = yield* Database.load(data.initiative);
+      invariant(Obj.instanceOf(Initiative.Initiative, initiative));
+      invariant(initiative.chat, 'Initiative has no chat.');
+
+      const { id, name, queue } = initiative;
+      if (!queue) {
+        throw new Error('Initiative has no queue.');
+      }
+
+      const plan = yield* Database.load(initiative.plan);
+      const spec = yield* Database.load(initiative.spec);
+
+      const {
+        value: { isRelevant },
+      } = yield* LanguageModel.generateObject({
+        schema: Schema.Struct({
+          isRelevant: Schema.Boolean,
+        }),
+        prompt: Prompt.fromMessages([
+          Prompt.systemMessage({
+            content: trim`
+              You are a qualifying agent that determines if the event is relevant to the initiative.
+              Respond with true if the event is relevant to the initiative, false otherwise.
+              If you are not sure, return true.
+              The qualified events will be forwarded to the larger agent that will process them.
+              <initiative id="${id}" name="${name}">
+                <spec>
+                ${spec.content}
+                </spec>
+                <plan>
+                  ${formatPlan(plan)}
+                </plan>
+              </initiative>
+            `,
+          }),
+          Prompt.userMessage({
+            content: [
+              Prompt.makePart('text', {
+                text: trim`
+                  <event>
+                    ${JSON.stringify(data.event, null, 2)}
+                  </event>
+                `,
+              }),
+            ],
+          }),
+        ]),
+      });
+
+      if (isRelevant) {
+        const queueTarget = yield* Database.load(queue);
+
+        if ('queue' in data.event && data.event.item) {
+          const obj = data.event.item;
+          yield* Effect.promise(() => queueTarget.append([obj]));
+        } else if ('subject' in data.event && Ref.isRef(data.event.subject)) {
+          const obj = yield* Database.load(data.event.subject);
+          yield* Effect.promise(() => queueTarget.append([obj]));
+        } else {
+          throw new Error('Invalid event.');
+        }
+      }
+    },
+    Effect.scoped,
+    Effect.provide(AiService.model('@anthropic/claude-sonnet-4-5')),
+  ),
+});

package/src/initiative/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { Initiative } from './Initiative';
+export { makeInitialized, resetChatHistory, getFromChatContext } from './util';
+export { getFunctions, makeBlueprint } from './blueprint';
+export * from './functions';
+export * from './plan';