@dxos/assistant-toolkit 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/src/blueprints/project/blueprint.test.ts

@@ -7,39 +7,42 @@ import * as Effect from 'effect/Effect';
 import * as Exit from 'effect/Exit';
 
 import { MemoizedAiService } from '@dxos/ai/testing';
-import { AiConversation } from '@dxos/assistant';
-import { AssistantTestLayer, AssistantTestLayerWithTriggers } from '@dxos/assistant/testing';
-import { Blueprint } from '@dxos/blueprints';
+import { AiSession } from '@dxos/assistant';
 import { SpaceProperties } from '@dxos/client-protocol';
-import { Database, Feed, Obj, Ref } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
+import { Blueprint, Trigger, Operation, OperationHandlerSet } from '@dxos/compute';
+import { Collection, Database, Feed, Filter, Obj, Query, Ref } from '@dxos/echo';
 import { acquireReleaseResource } from '@dxos/effect';
 import { TestHelpers } from '@dxos/effect/testing';
-import { QueueService, Trigger } from '@dxos/functions';
 import { TriggerDispatcher } from '@dxos/functions-runtime';
+import { AssistantTestLayerWithTriggers } from '@dxos/functions-runtime/testing';
 import { invariant } from '@dxos/invariant';
 import { ObjectId } from '@dxos/keys';
-import { Operation, OperationHandlerSet } from '@dxos/operation';
-import { MarkdownBlueprint } from '@dxos/plugin-markdown/blueprints';
+import { MarkdownBlueprint } from '@dxos/plugin-markdown';
+import { Markdown } from '@dxos/plugin-markdown';
+import { MarkdownOperationHandlerSet } from '@dxos/plugin-markdown/plugin';
 import { WithProperties } from '@dxos/plugin-markdown/testing';
-import { Markdown } from '@dxos/plugin-markdown/types';
 import { Text } from '@dxos/schema';
 import { Message } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { Chat, Plan, Project } from '../../types';
-import { MarkdownHandlers } from '../markdown';
+import { Chat, Plan, Agent } from '../../types';
 import { PlanningBlueprint, PlanningHandlers } from '../planning';
-import ProjectBlueprintDef from './blueprint';
-import { Agent, ProjectHandlers } from './functions';
+import { AgentWizardHandlers, SyncTriggers } from '../project-wizard';
+import AgentBlueprintDef from './blueprint';
+import { AgentWorker, AgentBlueprintHandlers } from './functions';
 
 ObjectId.dangerouslyDisableRandomness();
 
 const TestLayer = AssistantTestLayerWithTriggers({
   aiServicePreset: 'edge-remote',
-  operationHandlers: OperationHandlerSet.merge(ProjectHandlers, MarkdownHandlers, PlanningHandlers),
+  operationHandlers: OperationHandlerSet.merge(
+    AgentBlueprintHandlers,
+    AgentWizardHandlers,
+    MarkdownOperationHandlerSet,
+    PlanningHandlers,
+  ),
   types: [
-    Project.Project,
+    Agent.Agent,
     Plan.Plan,
     Chat.CompanionTo,
     Chat.Chat,
@@ -60,106 +63,85 @@ const SYSTEM = trim`
   DO NOT PRETEND TO DO SOMETHING YOU CAN'T DO.
 `;
 
-const AddArtifactTestLayer = AssistantTestLayer({
-  aiServicePreset: 'edge-remote',
-  operationHandlers: OperationHandlerSet.merge(ProjectHandlers, MarkdownHandlers),
-  types: [
-    Project.Project,
-    Plan.Plan,
-    Chat.CompanionTo,
-    Chat.Chat,
-    SpaceProperties,
-    Blueprint.Blueprint,
-    Trigger.Trigger,
-    Text.Text,
-    Markdown.Document,
-    Collection.Collection,
-  ],
-  tracing: 'pretty',
-});
-
-describe('Project AddArtifact', () => {
-  const blueprint = ProjectBlueprintDef.make();
+describe('Agent', () => {
+  const blueprint = AgentBlueprintDef.make();
 
   it.scoped(
-    'agent adds artifact to project',
+    'agent adds artifact to agent',
     Effect.fnUntraced(
       function* (_) {
-        const project = yield* Database.add(
-          yield* Project.makeInitialized(
-            {
-              name: 'Test Project',
-              spec: 'A test project for adding artifacts.',
-              blueprints: [Ref.make(MarkdownBlueprint.make())],
-            },
-            blueprint,
-          ),
+        const agent = yield* Agent.makeInitialized(
+          {
+            name: 'Test Project',
+            instructions: 'A test project for adding artifacts.',
+            blueprints: [Ref.make(MarkdownBlueprint.make())],
+          },
+          blueprint,
         );
         yield* Database.flush();
 
         const document = yield* Database.add(
           Obj.make(Markdown.Document, {
             name: 'Test Document',
-            content: Ref.make(Text.make('This is a test document with some content.')),
+            content: Ref.make(Text.make({ content: 'This is a test document with some content.' })),
           }),
         );
         yield* Database.flush();
 
-        expect(project.artifacts).toHaveLength(0);
+        expect(agent.artifacts).toHaveLength(0);
 
-        const chatFeed = project.chat?.target?.feed?.target;
-        invariant(chatFeed, 'Project chat feed not found.');
+        const chatFeed = agent.chat?.target?.feed?.target;
+        invariant(chatFeed, 'Agent chat feed not found.');
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation({ feed: chatFeed, runtime }));
-        yield* Effect.promise(() => conversation.context.open());
-
-        const documentDxn = Obj.getDXN(document);
-        yield* conversation.createRequest({
-          system: SYSTEM,
-          prompt: `Please add the document ${documentDxn} as an artifact named "My Test Document" to this project.`,
-        });
-
-        expect(project.artifacts).toHaveLength(1);
-        expect(project.artifacts[0].name).toBe('My Test Document');
-        const artifactData = yield* project.artifacts[0].data.pipe(Database.load);
+        const session = yield* acquireReleaseResource(() => new AiSession.Session({ feed: chatFeed, runtime }));
+        yield* Effect.promise(() => session.context.open());
+
+        const documentDXN = Obj.getDXN(document);
+        yield* session
+          .createRequest({
+            system: SYSTEM,
+            prompt: `Please add the document ${documentDXN} as an artifact named "My Test Document" to this agent.`,
+          })
+          .pipe(Effect.provide(session.makeToolExecutionServices()));
+
+        expect(agent.artifacts).toHaveLength(1);
+        expect(agent.artifacts[0].name).toBe('My Test Document');
+        const artifactData = yield* agent.artifacts[0].data.pipe(Database.load);
         expect(Obj.instanceOf(Markdown.Document, artifactData)).toBe(true);
       },
-      Effect.provide(AddArtifactTestLayer),
+      Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
     ),
     MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
   );
-});
 
-describe.runIf(TestHelpers.tagEnabled('flaky'))('Project', () => {
-  const blueprint = ProjectBlueprintDef.make();
   it.scoped(
     'shopping list',
     Effect.fnUntraced(
       function* (_) {
-        const project = yield* Database.add(
-          yield* Project.makeInitialized(
-            {
-              name: 'Shopping list',
-              spec: 'Keep a shopping list of items to buy.',
-              blueprints: [Ref.make(MarkdownBlueprint.make())],
-            },
-            blueprint,
-          ),
+        const agent = yield* Agent.makeInitialized(
+          {
+            name: 'Shopping list',
+            instructions: 'Keep a shopping list of items to buy.',
+            blueprints: [Ref.make(MarkdownBlueprint.make())],
+          },
+          blueprint,
         );
-        const chatFeed = project.chat?.target?.feed?.target;
-        invariant(chatFeed, 'Project chat feed not found.');
+        const chatFeed = agent.chat?.target?.feed?.target;
+        invariant(chatFeed, 'Agent chat feed not found.');
         yield* Database.flush();
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation({ feed: chatFeed, runtime }));
-        yield* Effect.promise(() => conversation.context.open());
+        const session = yield* acquireReleaseResource(() => new AiSession.Session({ feed: chatFeed, runtime }));
+        yield* Effect.promise(() => session.context.open());
 
-        yield* conversation.createRequest({
-          system: SYSTEM,
-          prompt: `List ingredients for a scrambled eggs on a toast breakfast.`,
-        });
+        yield* session
+          .createRequest({
+            system: SYSTEM,
+            prompt: `List ingredients for a scrambled eggs on a toast breakfast.`,
+          })
+          .pipe(Effect.provide(session.makeToolExecutionServices()));
 
-        console.log(yield* Effect.promise(() => dumpProject(project)));
+        console.log(yield* Effect.promise(() => dumpAgent(agent)));
       },
       Effect.provide(TestLayer),
       TestHelpers.provideTestContext,
@@ -171,45 +153,40 @@ describe.runIf(TestHelpers.tagEnabled('flaky'))('Project', () => {
     'expense tracking list',
     Effect.fnUntraced(
       function* (_) {
-        const project = yield* Database.add(
-          yield* Project.makeInitialized(
-            {
-              name: 'Expense tracking',
-              spec: trim`
-                Keep a list of expenses in a markdown document (create artifact "Expenses").
-                Process incoming emails, add the relevant ones to the list.
-
-                Format:
-
-                ## Expenses
-                - Flight to London (2026-02-01): £100
-                - Hotel in London (2026-02-01): £100
-              `,
-              blueprints: [Ref.make(MarkdownBlueprint.make())],
-            },
-            blueprint,
-          ),
+        const agent = yield* Agent.makeInitialized(
+          {
+            name: 'Expense tracking',
+            instructions: trim`
+              Keep a list of expenses in a markdown document (create artifact "Expenses").
+              Process incoming emails, add the relevant ones to the list.
+
+              Format:
+
+              ## Expenses
+              - Flight to London (2026-02-01): £100
+              - Hotel in London (2026-02-01): £100
+            `,
+            blueprints: [Ref.make(MarkdownBlueprint.make())],
+          },
+          blueprint,
         );
         yield* Database.flush();
 
-        const inboxQueue = yield* QueueService.createQueue();
+        const inboxFeed = yield* Database.add(Feed.make());
         yield* Database.add(
           Trigger.make({
             enabled: true,
-            spec: {
-              kind: 'queue',
-              queue: inboxQueue.dxn.toString(),
-            },
-            function: Ref.make(Operation.serialize(Agent)),
+            spec: Trigger.specFeed(inboxFeed),
+            function: Ref.make(Operation.serialize(AgentWorker)),
             input: {
-              project: Ref.make(project),
+              agent: Ref.make(agent),
               event: '{{event}}',
             },
           }),
         );
 
-        yield* QueueService.append(
-          inboxQueue,
+        yield* Feed.append(
+          inboxFeed,
           TEST_MESSAGES.map((message) => Obj.clone(message)),
         );
 
@@ -217,7 +194,7 @@ describe.runIf(TestHelpers.tagEnabled('flaky'))('Project', () => {
         const invocations = yield* dispatcher.invokeScheduledTriggers({ kinds: ['queue'], untilExhausted: true });
         expect(invocations.every((invocation) => Exit.isSuccess(invocation.result))).toBe(true);
 
-        console.log(yield* Effect.promise(() => dumpProject(project)));
+        console.log(yield* Effect.promise(() => dumpAgent(agent)));
       },
       WithProperties,
       Effect.provide(TestLayer),
@@ -226,56 +203,98 @@ describe.runIf(TestHelpers.tagEnabled('flaky'))('Project', () => {
     MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
   );
 
+  it.scoped(
+    'cron field creates a timer trigger that invokes the agent worker',
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const cron = '*/5 * * * *';
+        const agent = yield* Agent.makeInitialized(
+          {
+            name: 'Scheduled agent',
+            instructions: 'A scheduled agent that runs on a timer.',
+            blueprints: [Ref.make(MarkdownBlueprint.make())],
+            cron,
+          },
+          blueprint,
+        );
+        yield* Database.flush();
+
+        yield* Operation.invoke(SyncTriggers, { agent: Ref.make(agent) });
+
+        const triggers = yield* Database.runQuery(
+          Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.blueprint.test.timer'),
+        );
+        const timerTriggers = triggers.filter(
+          (trigger) => trigger.spec?.kind === 'timer' && trigger.spec.cron === cron,
+        );
+        expect(timerTriggers).toHaveLength(1);
+
+        const timerTrigger = timerTriggers[0];
+        invariant(timerTrigger.spec?.kind === 'timer');
+        expect(timerTrigger.spec.cron).toBe(cron);
+        expect(timerTrigger.enabled).toBe(true);
+
+        // Timer trigger bypasses the qualifier and points to the agent worker.
+        invariant(timerTrigger.function);
+        const operation = yield* Database.load(timerTrigger.function);
+        invariant(Obj.instanceOf(Operation.PersistentOperation, operation));
+        expect(Obj.getMeta(operation).key).toBe(AgentWorker.meta.key);
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
   it.scoped(
     'planning',
     Effect.fnUntraced(
       function* (_) {
-        const project = yield* Database.add(
-          yield* Project.makeInitialized(
-            {
-              name: 'Egg making',
-              spec: trim`
-                I'm testing how planning (task management) works.
-                Create tasks to make scrambled eggs.
-
-                Then simulate this plan execution in a markdown document.
-                The document should reflect the state of all objects involved in the cooking process.
-                The document should also have the log of actions taken.
-
-                Important: simualte actions one by one, in the order they are listed.
-                Simlate by updating the local document.
-
-                <example>
-                  # State
-
-                  - 2 raw eggs
-                  - 1 frying pan
-                  
-                  # Action log
-                  
-                  - Taken 2 raw eggs out of the fridge.
-                </example>
-              `,
-              blueprints: [Ref.make(MarkdownBlueprint.make()), Ref.make(Obj.clone(PlanningBlueprint.make()))],
-            },
-            blueprint,
-          ),
+        const agent = yield* Agent.makeInitialized(
+          {
+            name: 'Egg making',
+            instructions: trim`
+              I'm testing how planning (task management) works.
+              Create tasks to make scrambled eggs.
+
+              Then simulate this plan execution in a markdown document.
+              The document should reflect the state of all objects involved in the cooking process.
+              The document should also have the log of actions taken.
+
+              Important: simualte actions one by one, in the order they are listed.
+              Simlate by updating the local document.
+
+              <example>
+                # State
+
+                - 2 raw eggs
+                - 1 frying pan
+                
+                # Action log
+                
+                - Taken 2 raw eggs out of the fridge.
+              </example>
+            `,
+            blueprints: [Ref.make(MarkdownBlueprint.make()), Ref.make(Obj.clone(PlanningBlueprint.make()))],
+          },
+          blueprint,
         );
         yield* Database.flush();
 
-        const chatFeed = project.chat?.target?.feed?.target;
-        invariant(chatFeed, 'Project chat feed not found.');
+        const chatFeed = agent.chat?.target?.feed?.target;
+        invariant(chatFeed, 'Agent chat feed not found.');
         yield* Database.flush();
         const runtime = yield* Effect.runtime<Feed.FeedService>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation({ feed: chatFeed, runtime }));
-        yield* Effect.promise(() => conversation.context.open());
+        const session = yield* acquireReleaseResource(() => new AiSession.Session({ feed: chatFeed, runtime }));
+        yield* Effect.promise(() => session.context.open());
 
-        yield* conversation.createRequest({
-          system: SYSTEM,
-          prompt: `Go`,
-        });
+        yield* session
+          .createRequest({
+            system: SYSTEM,
+            prompt: `Go`,
+          })
+          .pipe(Effect.provide(session.makeToolExecutionServices()));
 
-        console.log(yield* Effect.promise(() => dumpProject(project)));
+        console.log(yield* Effect.promise(() => dumpAgent(agent)));
       },
       WithProperties,
       Effect.provide(TestLayer),
@@ -283,17 +302,57 @@ describe.runIf(TestHelpers.tagEnabled('flaky'))('Project', () => {
     ),
     MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
   );
+
+  it.scoped(
+    'sync-triggers sets trigger enabled from agent.enabled',
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const agent = yield* Agent.makeInitialized(
+          {
+            name: 'Toggle agent',
+            instructions: 'Test enabled propagation.',
+            blueprints: [Ref.make(MarkdownBlueprint.make())],
+            enabled: false,
+            cron: '0 9 * * *',
+          },
+          blueprint,
+        );
+        yield* Database.flush();
+
+        yield* Operation.invoke(SyncTriggers, { agent: Ref.make(agent) });
+
+        const triggers = yield* Database.runQuery(
+          Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.blueprint.test.toggle-enabled'),
+        );
+        expect(triggers.every((trigger) => trigger.enabled === false)).toBe(true);
+
+        Obj.update(agent, (agent) => {
+          agent.enabled = true;
+        });
+        yield* Database.flush();
+        yield* Operation.invoke(SyncTriggers, { agent: Ref.make(agent) });
+
+        const triggersAfter = yield* Database.runQuery(
+          Query.select(Filter.type(Trigger.Trigger)).debugLabel('assistant-toolkit.blueprint.test.after'),
+        );
+        expect(triggersAfter).toHaveLength(triggers.length);
+        expect(triggersAfter.every((trigger) => trigger.enabled === true)).toBe(true);
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
 });
 
-const dumpProject = async (project: Project.Project) => {
+const dumpAgent = async (agent: Agent.Agent) => {
   let text = '';
-  text += `============== Project: ${project.name} ==============\n\n`;
-  text += `============== Spec ==============\n\n`;
-  text += `${await project.spec.load().then((_) => _.content)}\n`;
+  text += `============== Agent: ${agent.name} ==============\n\n`;
+  text += `============== Instructions ==============\n\n`;
+  text += `${await agent.instructions.load().then((_) => _.content)}\n`;
   text += `============== Plan ==============\n\n`;
-  text += `${await project.plan?.load().then((_) => Plan.formatPlan(_))}\n`;
+  text += `${await agent.plan?.load().then((_) => Plan.formatPlan(_))}\n`;
   text += `============== Artifacts ==============\n\n`;
-  for (const artifact of project.artifacts) {
+  for (const artifact of agent.artifacts) {
     const data = await artifact.data.load();
     text += `============== ${artifact.name} (${Obj.getTypename(data)}) ==============\n`;
     if (Obj.instanceOf(Markdown.Document, data)) {

package/src/blueprints/project/blueprint.ts

@@ -2,36 +2,35 @@
 // Copyright 2026 DXOS.org
 //
 
-import { type AppCapabilities } from '@dxos/app-toolkit';
-import { Blueprint, Template } from '@dxos/blueprints';
+import { Blueprint, Template } from '@dxos/compute';
 import { trim } from '@dxos/util';
 
 import { AddArtifact } from './functions';
 
-const BLUEPRINT_KEY = 'org.dxos.blueprint.project';
+const BLUEPRINT_KEY = 'org.dxos.blueprint.agent';
 
 /**
- * Creates the Project blueprint. This is a function to avoid circular dependency issues.
+ * Creates the Agent blueprint. This is a function to avoid circular dependency issues.
  */
-// TODO(dmaretskyi): Combine with Project Wizard
+// TODO(dmaretskyi): Combine with Agent Wizard.
 const make = () =>
   Blueprint.make({
     key: BLUEPRINT_KEY,
-    name: 'Project blueprint',
+    name: 'Agent blueprint',
     instructions: Template.make({
       source: trim`
-        You work on an project. Each project has a spec - the goal of the project.
-        The project plan shows the current progress of the project.
-        Project has an number of associated artifacts you can read/write.
+        You work on an agent. Each agent has instructions - the goal of the agent.
+        The agent plan shows the current progress of the agent.
+        Agent has a number of associated artifacts you can read/write.
         You can edit them if necessary.
 
-        IMPORTANT: When creating a new artifact, always add it to the project using the add-artifact function.
+        IMPORTANT: When creating a new artifact, always add it to the agent using the add-artifact function.
 
-        {{#with project}}
-        <project id="{{id}}" name="{{name}}">
-          <spec>
-            {{spec}}
-          </spec>
+        {{#with agent}}
+        <agent id="{{id}}" name="{{name}}">
+          <instructions>
+            {{instructions}}
+          </instructions>
           <plan>
             {{plan}}
           </plan>
@@ -43,21 +42,21 @@ const make = () =>
             </artifact>
           {{/each}}
           </artifacts>
-        </project>
+        </agent>
         {{/with}}
       `,
       inputs: [
         {
-          name: 'project',
-          kind: 'function',
-          function: 'org.dxos.function.project.get-context',
+          name: 'agent',
+          kind: 'operation',
+          operation: 'org.dxos.function.agent.get-context',
         },
       ],
     }),
     tools: Blueprint.toolDefinitions({ operations: [AddArtifact] }),
   });
 
-const blueprint: AppCapabilities.BlueprintDefinition = {
+const blueprint: Blueprint.Definition = {
   key: BLUEPRINT_KEY,
   make,
 };

package/src/blueprints/project/functions/add-artifact.ts

@@ -4,10 +4,10 @@
 
 import * as Effect from 'effect/Effect';
 
+import { Operation } from '@dxos/compute';
 import { Database, Obj } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
 
-import { Project } from '../../../types';
+import { Agent } from '../../../types';
 import { AddArtifact } from './definitions';
 
 export default AddArtifact.pipe(
@@ -17,14 +17,15 @@ export default AddArtifact.pipe(
         throw new Error('Artifact not found.');
       }
 
-      const project = yield* Project.getFromChatContext;
+      const agent = yield* Agent.getFromChatContext;
 
-      Obj.change(project, (project) => {
-        project.artifacts.push({
+      Obj.update(agent, (agent) => {
+        agent.artifacts.push({
           name,
           data: artifact,
         });
       });
     }) as any,
   ),
+  Operation.opaqueHandler,
 );