@dxos/assistant-toolkit 0.9.0 → 0.9.1-main.c7dcc2e112

package/src/blueprints/delegation/operations/delegate-task.test.ts

@@ -26,6 +26,11 @@ const TestLayer = AssistantTestLayer({
   disableLlmMemoization: true,
 });
 
+const invokeDelegateTask = (input: { id?: Plan.TaskId; title?: string }, chatFeed: Feed.Feed) =>
+  Operation.invoke(DelegateTask, input).pipe(
+    Effect.provide(Operation.withInvocationOptions({ conversation: Obj.getURI(chatFeed) })),
+  );
+
 describe('DelegateTask', () => {
   it.scoped(
     'adds an in-progress task to the agent plan for delegated work',
@@ -40,13 +45,72 @@ describe('DelegateTask', () => {
         const chatFeed = agent.chat?.target?.feed?.target;
         invariant(chatFeed, 'Agent chat feed not found.');
 
-        yield* Operation.invoke(DelegateTask, { title: 'Research widgets' }).pipe(
-          Effect.provide(Operation.withInvocationOptions({ conversation: Obj.getURI(chatFeed) })),
-        );
+        yield* invokeDelegateTask({ title: 'Research widgets' }, chatFeed);
 
         const plan = yield* Database.load(agent.plan);
         expect(plan.tasks).toHaveLength(1);
-        expect(plan.tasks[0]).toMatchObject({ title: 'Research widgets', status: 'in-progress' });
+        expect(plan.tasks[0]).toMatchObject({
+          title: 'Research widgets',
+          status: 'in-progress',
+          delegated: true,
+        });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.scoped(
+    'delegates an existing plan task by id without duplicating',
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const agent = yield* Agent.makeInitialized(
+          { name: 'Supervisor', instructions: 'Test.' },
+          DelegationBlueprint.make(),
+        );
+        const plan = yield* Database.load(agent.plan);
+        const taskId = Plan.TaskId.make('1-ab');
+        Obj.update(plan, (plan) => {
+          plan.tasks.push({ id: taskId, title: 'Research widgets', status: 'todo' });
+        });
+        yield* Database.flush();
+
+        const chatFeed = agent.chat?.target?.feed?.target;
+        invariant(chatFeed, 'Agent chat feed not found.');
+
+        yield* invokeDelegateTask({ id: taskId }, chatFeed);
+
+        const updated = yield* Database.load(agent.plan);
+        expect(updated.tasks).toHaveLength(1);
+        expect(updated.tasks[0]).toMatchObject({
+          id: taskId,
+          title: 'Research widgets',
+          status: 'in-progress',
+          delegated: true,
+        });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.scoped(
+    'fails when both id and title are provided',
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const agent = yield* Agent.makeInitialized(
+          { name: 'Supervisor', instructions: 'Test.' },
+          DelegationBlueprint.make(),
+        );
+        yield* Database.flush();
+
+        const chatFeed = agent.chat?.target?.feed?.target;
+        invariant(chatFeed, 'Agent chat feed not found.');
+
+        const exit = yield* invokeDelegateTask({ id: Plan.TaskId.make('1-ab'), title: 'New task' }, chatFeed).pipe(
+          Effect.exit,
+        );
+        expect(exit._tag).toBe('Failure');
       },
       Effect.provide(TestLayer),
       TestHelpers.provideTestContext,

package/src/blueprints/delegation/operations/delegate-task.ts

@@ -18,15 +18,18 @@ export const DelegateTask = Operation.make({
     key: DXN.make('org.dxos.function.delegation.delegateTask'),
     name: 'Delegate task',
     description: trim`
-      Delegate a unit of work to a sub-agent. 
-      Records the work as an in-progress task on the plan and returns the updated plan. 
-      Use this to hand off work that can proceed in the background while you continue the conversation.
+      Delegate a unit of work to a sub-agent.
+      Provide either \`id\` (an existing plan task from update-tasks) or \`title\` (to create a new task).
+      Marks the task in-progress and delegated so the supervisor spawns a background sub-agent.
     `,
     icon: 'ph--share-network--regular',
   },
   input: Schema.Struct({
-    title: Schema.String.annotations({
-      description: 'Short title describing the work to delegate to a sub-agent.',
+    id: Schema.optional(Plan.TaskId).annotations({
+      description: 'Id of an existing plan task to delegate (from update-tasks).',
+    }),
+    title: Schema.optional(Schema.String).annotations({
+      description: 'Title for a new task to create and delegate. Omit when delegating by id.',
     }),
   }),
   output: Schema.Any,
@@ -38,14 +41,47 @@ export const DelegateTask = Operation.make({
  */
 export default DelegateTask.pipe(
   Operation.withHandler(
-    Effect.fn(function* ({ title }) {
+    Effect.fn(function* ({ id, title }) {
+      const hasId = id !== undefined;
+      const hasTitle = title !== undefined && title.length > 0;
+      if (hasId === hasTitle) {
+        return yield* Effect.fail(
+          new Error('Provide exactly one of `id` (existing plan task) or `title` (new task to create).'),
+        );
+      }
+
       const agent = yield* Agent.getFromChatContext;
       const plan = yield* Database.load(agent.plan);
-      Obj.update(plan, (plan) => {
-        // Mark as delegated so the supervisor's reconcile loop picks it up (and ordinary
-        // `update-tasks` tasks are NOT spawned as sub-agents).
-        Plan.addTasks(plan, [{ title, status: 'in-progress', delegated: true }]);
-      });
+
+      if (hasId) {
+        const existing = plan.tasks.find((task) => task.id === id);
+        if (!existing) {
+          return yield* Effect.fail(new Error(`Plan task not found: ${id}`));
+        }
+        if (existing.status === 'done' || existing.status === 'failed') {
+          return yield* Effect.fail(
+            new Error(`Plan task "${id}" is already ${existing.status} and cannot be delegated.`),
+          );
+        }
+
+        Obj.update(plan, (plan) => {
+          const task = plan.tasks.find((task) => task.id === id);
+          if (task) {
+            task.delegated = true;
+            task.status = 'in-progress';
+          }
+        });
+      } else {
+        if (title === undefined) {
+          return yield* Effect.fail(
+            new Error('Provide exactly one of `id` (existing plan task) or `title` (new task to create).'),
+          );
+        }
+        Obj.update(plan, (plan) => {
+          Plan.addTasks(plan, [{ title, status: 'in-progress', delegated: true }]);
+        });
+      }
+
       return trim`
         Delegated work as an in-progress task. Current plan:
         <plan>