@dxos/assistant-toolkit 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/blueprints/{planning/planning-blueprint.test.ts → planning-old/blueprint.test.ts}

@@ -7,51 +7,45 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AiService } from '@dxos/ai';
+import { GenericToolkit } from '@dxos/ai';
 import { AiServiceTestingPreset } from '@dxos/ai/testing';
-import {
-  AiConversation,
-  type ContextBinding,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
-} from '@dxos/assistant';
+import { AiConversation, type ContextBinding, ToolExecutionServices } from '@dxos/assistant';
 import { Blueprint } from '@dxos/blueprints';
 import { Obj, Ref } from '@dxos/echo';
-import { TestHelpers, acquireReleaseResource } from '@dxos/effect';
-import {
-  ComputeEventLogger,
-  DatabaseService,
-  FunctionImplementationResolver,
-  FunctionInvocationService,
-  QueueService,
-  TracingService,
-} from '@dxos/functions';
-import { TestDatabaseLayer } from '@dxos/functions/testing';
+import { Database } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { TestHelpers } from '@dxos/effect/testing';
+import { QueueService, Trace, TracingService } from '@dxos/functions';
+import { FunctionImplementationResolver } from '@dxos/functions-runtime';
+import { FunctionInvocationServiceLayerTestMocked, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
 import { log } from '@dxos/log';
 import { Markdown } from '@dxos/plugin-markdown/types';
-import { DataType } from '@dxos/schema';
+import { Text } from '@dxos/schema';
+import { type Message } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { Tasks } from '../../functions';
-import { type TestStep, runSteps, testToolkit } from '../testing';
+import { type TestStep, runSteps } from '../testing';
 
-import blueprint from './planning-blueprint';
+import PlanningOldBlueprint from './blueprint';
+import { TaskHandlers } from './functions';
 
 describe('Planning Blueprint', { timeout: 120_000 }, () => {
+  const blueprint = PlanningOldBlueprint.make();
   it.scoped(
     'planning blueprint',
     Effect.fn(
       function* ({ expect }) {
-        const queue = yield* QueueService.createQueue<DataType.Message | ContextBinding>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation(queue));
+        const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
+        const conversation = yield* acquireReleaseResource(() => new AiConversation({ queue }));
 
-        yield* DatabaseService.add(blueprint);
+        yield* Database.add(blueprint);
         yield* Effect.promise(() =>
           conversation.context.bind({
             blueprints: [Ref.make(blueprint)],
           }),
         );
 
-        const artifact = yield* DatabaseService.add(Markdown.makeDocument());
+        const artifact = yield* Database.add(Markdown.make());
         let prevContent = artifact.content;
         const matchList =
           ({ includes = [], excludes = [] }: { includes: RegExp[]; excludes?: RegExp[] }) =>
@@ -107,22 +101,21 @@ describe('Planning Blueprint', { timeout: 120_000 }, () => {
       },
       Effect.provide(
         Layer.mergeAll(
-          TestDatabaseLayer({ types: [DataType.Text, Markdown.Document, Blueprint.Blueprint] }),
-          makeToolResolverFromFunctions([Tasks.read, Tasks.update], testToolkit),
-          makeToolExecutionServiceFromFunctions(testToolkit, testToolkit.toLayer({}) as any),
+          TestDatabaseLayer({ types: [Text.Text, Markdown.Document, Blueprint.Blueprint] }),
+          ToolExecutionServices,
           AiService.model('@anthropic/claude-3-5-sonnet-20241022'),
         ).pipe(
           Layer.provideMerge(
-            FunctionInvocationService.layerTestMocked({ functions: [Tasks.read, Tasks.update] }).pipe(
-              Layer.provideMerge(ComputeEventLogger.layerFromTracing),
-              Layer.provideMerge(TracingService.layerNoop),
+            FunctionInvocationServiceLayerTestMocked({ functions: TaskHandlers }).pipe(
+              Layer.provideMerge(Layer.mergeAll(TracingService.layerNoop, Trace.writerLayerNoop)),
             ),
           ),
-          Layer.provideMerge(FunctionImplementationResolver.layerTest({ functions: [Tasks.read, Tasks.update] })),
-          Layer.provideMerge(TestDatabaseLayer({ types: [DataType.Text, Markdown.Document, Blueprint.Blueprint] })),
-          Layer.provideMerge(AiServiceTestingPreset('direct')),
+          Layer.provideMerge(FunctionImplementationResolver.layerTest({ functions: TaskHandlers })),
+          Layer.provideMerge(TestDatabaseLayer({ types: [Text.Text, Markdown.Document, Blueprint.Blueprint] })),
+          Layer.provideMerge(Layer.mergeAll(GenericToolkit.providerEmpty, AiServiceTestingPreset('direct'))),
         ),
       ),
+      TestHelpers.provideTestContext,
       TestHelpers.taggedTest('llm'),
     ),
   );

package/src/blueprints/{planning/planning-blueprint.ts → planning-old/blueprint.ts}

@@ -2,13 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ToolId } from '@dxos/ai';
+import { type AppCapabilities } from '@dxos/app-toolkit';
 import { Blueprint } from '@dxos/blueprints';
-import { Obj, Ref } from '@dxos/echo';
-import { DataType } from '@dxos/schema';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
 import { trim } from '@dxos/util';
 
-import { Tasks } from '../../functions';
+import { ReadTasks, UpdateTasks } from './functions';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.planning';
 
 /**
  * Agent prompt instructions for managing hierarchical task lists.
@@ -85,14 +87,20 @@ const instructions = trim`
   - Be precise with task descriptions and hierarchy levels
 `;
 
-export const blueprint: Blueprint.Blueprint = Obj.make(Blueprint.Blueprint, {
-  key: 'dxos.org/blueprint/planning',
-  name: 'Planning',
-  description: 'Plans and tracks complex tasks with artifact management.',
-  instructions: {
-    source: Ref.make(DataType.makeText(instructions)),
-  },
-  tools: [Tasks.read, Tasks.update].map((fn) => ToolId.make(fn.key)),
-});
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Planning',
+    description: 'Plans and tracks complex tasks with artifact management.',
+    instructions: {
+      source: Ref.make(Text.make(instructions)),
+    },
+    tools: Blueprint.toolDefinitions({ operations: [ReadTasks, UpdateTasks] }),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
 
 export default blueprint;

package/src/blueprints/planning-old/functions/definitions.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Database, Ref } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { Markdown } from '@dxos/plugin-markdown/types';
+
+export const ReadTasks = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.read-tasks',
+    name: 'Read',
+    description: 'Read markdown tasks.',
+  },
+  input: Schema.Struct({
+    doc: Ref.Ref(Markdown.Document).annotations({
+      description: 'The ID of the document to read.',
+    }),
+  }),
+  output: Schema.Struct({
+    content: Schema.String,
+  }),
+  services: [Database.Service],
+});
+
+export const UpdateTasks = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.update-tasks',
+    name: 'Update markdown',
+    description: 'Creates and updates tasks in markdown documents.',
+  },
+  input: Schema.Struct({
+    doc: Ref.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.',
+        }),
+      ),
+    ),
+  }),
+  output: Schema.Struct({
+    content: Schema.String,
+    numberedContent: Schema.String.annotations({
+      description: 'Content with line numbers for agent reference.',
+    }),
+  }),
+  services: [Database.Service],
+});

package/src/blueprints/planning-old/functions/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * from './definitions';
+
+export const TaskHandlers = OperationHandlerSet.lazy(
+  () => import('./read'),
+  () => import('./update'),
+);

package/src/blueprints/planning-old/functions/read.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { ReadTasks } from './definitions';
+
+export default ReadTasks.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ doc }) {
+      const document = yield* Database.load(doc);
+
+      const { content } = yield* Database.load(document.content);
+      const lines = content.split('\n');
+      const len = String(lines.length).length;
+      const numbered = lines.map((line, i) => `${String(i + 1).padStart(len, ' ')}. ${line}`).join('\n');
+      return { content: numbered };
+    }),
+  ),
+);

package/src/blueprints/planning-old/functions/update.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { UpdateTasks } from './definitions';
+import { MarkdownTasks, type TaskOperation } from './task-list';
+
+export default UpdateTasks.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ doc, operations = [] }) {
+      const document = yield* Database.load(doc);
+
+      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/blueprints/planning-old/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as PlanningOldBlueprint } from './blueprint';
+export { ReadTasks, UpdateTasks as PlanningOldUpdateTasks, TaskHandlers } from './functions';