@dxos/assistant-toolkit 0.8.4-main.3eb6e50203 → 0.8.4-main.3fbcb4aa9b

package/src/functions/tasks/update.ts

@@ -1,52 +0,0 @@
-//
-// 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/initiative/Initiative.ts

@@ -1,61 +0,0 @@
-//
-// 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

@@ -1,60 +0,0 @@
-//
-// 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

@@ -1,41 +0,0 @@
-//
-// 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

@@ -1,77 +0,0 @@
-//
-// 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

@@ -1,62 +0,0 @@
-//
-// 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),
-        Effect.catchTag('ObjectNotFoundError', () => Effect.succeed('No spec found.')),
-      ),
-      plan: yield* initiative.plan?.pipe(Database.load).pipe(
-        Effect.map(formatPlan),
-        Effect.catchTag('ObjectNotFoundError', () => Effect.succeed('No plan found.')),
-      ) ?? Effect.succeed('No plan found.'),
-      artifacts: yield* Effect.forEach(initiative.artifacts, (artifact) =>
-        Effect.gen(function* () {
-          return {
-            name: artifact.name,
-            type: yield* Database.load(artifact.data).pipe(
-              Effect.map(Obj.getTypename),
-              Effect.catchTag('ObjectNotFoundError', () => Effect.succeed('Artifact not found.')),
-            ),
-            dxn: artifact.data.dxn.toString(),
-          };
-        }),
-      ),
-    };
-  }, AiContextService.fixFunctionHandlerType),
-});

package/src/initiative/functions/index.ts

@@ -1,8 +0,0 @@
-//
-// 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

@@ -1,98 +0,0 @@
-//
-// 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

@@ -1,9 +0,0 @@
-//
-// 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';

package/src/initiative/util.ts

@@ -1,137 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Function from 'effect/Function';
-
-import { AiContextBinder, AiContextService, type ContextBinding } from '@dxos/assistant';
-import { type Blueprint } from '@dxos/blueprints';
-import { Database, Obj, Ref, Relation } from '@dxos/echo';
-import { type ObjectNotFoundError } from '@dxos/echo/Err';
-import { acquireReleaseResource } from '@dxos/effect';
-import { QueueService } from '@dxos/functions';
-import { invariant } from '@dxos/invariant';
-import { Text } from '@dxos/schema';
-import type { Message } from '@dxos/types';
-
-import * as Chat from '../chat/Chat';
-
-import { Initiative } from './Initiative';
-import { makePlan } from './plan';
-
-/**
- * Creates a fully initialized Initiative with chat, queue, and context bindings.
- *
- * @param props - Initiative properties including spec, plan, blueprints, and context objects.
- * @param blueprint - The blueprint to use for the initiative context.
- * @returns An Effect that yields the initialized Initiative.
- */
-export const makeInitialized = (
-  props: Omit<Obj.MakeProps<typeof Initiative>, 'spec' | 'plan' | 'artifacts' | 'subscriptions' | 'chat'> &
-    Partial<Pick<Obj.MakeProps<typeof Initiative>, 'artifacts' | 'subscriptions'>> & {
-      spec: string;
-      blueprints?: Ref.Ref<Blueprint.Blueprint>[];
-      contextObjects?: Ref.Ref<Obj.Any>[];
-    },
-  blueprint: Blueprint.Blueprint,
-): Effect.Effect<Initiative, never, QueueService | Database.Service> =>
-  Effect.gen(function* () {
-    const initiative = Obj.make(Initiative, {
-      ...props,
-      spec: Ref.make(Text.make(props.spec)),
-      plan: Ref.make(makePlan({ tasks: [] })),
-      artifacts: props.artifacts ?? [],
-      subscriptions: props.subscriptions ?? [],
-    });
-    yield* Database.add(initiative);
-    const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
-    const contextBinder = new AiContextBinder({ queue });
-    // TODO(dmaretskyi): Blueprint registry.
-    const initiativeBlueprint = yield* Database.add(Obj.clone(blueprint, { deep: true }));
-    yield* Effect.promise(() =>
-      contextBinder.bind({
-        blueprints: [Ref.make(initiativeBlueprint), ...(props.blueprints ?? [])],
-        objects: [Ref.make(initiative), ...(props.contextObjects ?? [])],
-      }),
-    );
-    const chat = yield* Database.add(
-      Chat.make({
-        queue: Ref.fromDXN(queue.dxn),
-      }),
-    );
-    yield* Database.add(
-      Relation.make(Chat.CompanionTo, {
-        [Relation.Source]: chat,
-        [Relation.Target]: initiative,
-      }),
-    );
-
-    const inputQueue = yield* QueueService.createQueue();
-
-    Obj.change(initiative, (initiative) => {
-      initiative.chat = Ref.make(chat);
-      initiative.queue = Ref.fromDXN(inputQueue.dxn);
-    });
-
-    return initiative;
-  });
-
-/**
- * Resets the initiative chat history by rebuilding the chat context.
- * Preserves the existing blueprints and objects from the current chat context.
- *
- * @param initiative - The initiative whose chat history should be reset. Must have an existing chat.
- * @returns An Effect that resets the chat history.
- */
-export const resetChatHistory = (
-  initiative: Initiative,
-): Effect.Effect<void, ObjectNotFoundError, QueueService | Database.Service> =>
-  Effect.gen(function* () {
-    invariant(initiative.chat, 'Initiative must have an existing chat to reset.');
-
-    const existingQueue = yield* initiative.chat.pipe(Database.load).pipe(
-      Effect.map((_) => _.queue),
-      Effect.flatMap(Database.load),
-    );
-    const existingContextBinder = yield* acquireReleaseResource(
-      () =>
-        new AiContextBinder({
-          queue: existingQueue,
-        }),
-    );
-    const blueprints = existingContextBinder.getBlueprints().map((blueprint) => Ref.make(blueprint));
-    const objects = existingContextBinder.getObjects().map((object) => Ref.make(object));
-
-    const queue = yield* QueueService.createQueue();
-    const contextBinder = new AiContextBinder({ queue });
-    yield* Effect.promise(() =>
-      contextBinder.bind({
-        blueprints,
-        objects,
-      }),
-    );
-    const chat = yield* Database.add(
-      Chat.make({
-        queue: Ref.fromDXN(queue.dxn),
-      }),
-    );
-    Obj.change(initiative, (initiative) => {
-      initiative.chat = Ref.make(chat);
-    });
-    yield* Database.add(
-      Relation.make(Chat.CompanionTo, {
-        [Relation.Source]: chat,
-        [Relation.Target]: initiative,
-      }),
-    );
-  }).pipe(Effect.scoped);
-
-export const getFromChatContext: Effect.Effect<Initiative, never, AiContextService> = Effect.gen(function* () {
-  const initiatives = yield* Function.pipe(AiContextService.findObjects(Initiative));
-  if (initiatives.length !== 1) {
-    throw new Error('There should be exactly one initiative in context. Got: ' + initiatives.length);
-  }
-  const initiative = initiatives[0];
-  return initiative;
-});

package/src/planning/blueprint.ts

@@ -1,14 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import { Blueprint } from '@dxos/blueprints';
-
-import { updateTasks } from './functions';
-
-export const PlanningBlueprint = Blueprint.make({
-  key: 'dxos.org/blueprint/planning',
-  name: 'Planning',
-  description: 'Plans and tracks complex tasks with artifact management.',
-  tools: Blueprint.toolDefinitions({ functions: [updateTasks] }),
-});

package/src/planning/functions/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-export { default as updateTasks } from './update-tasks';

package/src/planning/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-export { PlanningBlueprint } from './blueprint';
-export * as PlanningFunctions from './functions';