@dxos/assistant-toolkit 0.8.4-main.66e292d → 0.8.4-main.6fa680abb7

package/src/{functions/research → blueprints/research/functions}/research.test.ts

@@ -6,83 +6,53 @@ import { inspect } from 'node:util';
 
 import { describe, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-
-import { AiService, ConsolePrinter, MemoizedAiService } from '@dxos/ai';
-import { TestAiService } from '@dxos/ai/testing';
-import {
-  AiConversation,
-  type ContextBinding,
-  GenerationObserver,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
-} from '@dxos/assistant';
+
+import { ConsolePrinter } from '@dxos/ai';
+import { MemoizedAiService } from '@dxos/ai/testing';
+import { AiConversation, type ContextBinding, GenerationObserver } from '@dxos/assistant';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { Blueprint } from '@dxos/blueprints';
-import { Filter, Obj, Query, Ref } from '@dxos/echo';
-import { TestHelpers, acquireReleaseResource } from '@dxos/effect';
-import {
-  CredentialsService,
-  DatabaseService,
-  FunctionInvocationService,
-  QueueService,
-  TracingService,
-} from '@dxos/functions';
-import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
+import { Database, Filter, Obj, Query, Ref } from '@dxos/echo';
+import { acquireReleaseResource } from '@dxos/effect';
+import { TestHelpers } from '@dxos/effect/testing';
+import { FunctionInvocationService, QueueService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { ObjectId } from '@dxos/keys';
-import { MarkdownBlueprint, MarkdownFunction } from '@dxos/plugin-markdown/toolkit';
+import { MarkdownBlueprint } from '@dxos/plugin-markdown/blueprints';
 import { Markdown } from '@dxos/plugin-markdown/types';
 import { HasSubject, type Message, Organization } from '@dxos/types';
 
-import { ResearchBlueprint } from '../../blueprints';
-import { testToolkit } from '../../blueprints/testing';
+import ResearchBlueprint from '../blueprint';
+import { ResearchDataTypes, ResearchGraph } from '../types';
 
 import { default as createDocument } from './document-create';
 import { default as research } from './research';
-import { ResearchGraph, queryResearchGraph } from './research-graph';
-import { ResearchDataTypes } from './types';
 
 ObjectId.dangerouslyDisableRandomness();
 
-const TestLayer = Layer.mergeAll(
-  AiService.model('@anthropic/claude-opus-4-0'),
-  makeToolResolverFromFunctions(
-    [research, createDocument, MarkdownFunction.create, MarkdownFunction.open, MarkdownFunction.update],
-    testToolkit,
-  ),
-  makeToolExecutionServiceFromFunctions(testToolkit, testToolkit.toLayer({}) as any),
-).pipe(
-  Layer.provideMerge(
-    FunctionInvocationServiceLayerTest({
-      functions: [research, createDocument, MarkdownFunction.create, MarkdownFunction.open, MarkdownFunction.update],
-    }),
-  ),
-  Layer.provideMerge(
-    Layer.mergeAll(
-      TestAiService(),
-      TestDatabaseLayer({
-        spaceKey: 'fixed',
-        indexing: { vector: true },
-        types: [...ResearchDataTypes, ResearchGraph, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
-      }),
-      CredentialsService.configuredLayer([]),
-      TracingService.layerNoop,
-    ),
-  ),
-);
+const TestLayer = AssistantTestLayer({
+  functions: [research, createDocument, ...MarkdownBlueprint.functions],
+  types: [
+    ...ResearchDataTypes,
+    ResearchGraph.ResearchGraph,
+    Blueprint.Blueprint,
+    Markdown.Document,
+    HasSubject.HasSubject,
+  ],
+});
 
 describe('Research', () => {
   it.effect(
     'call a function to generate a research report',
     Effect.fnUntraced(
       function* (_) {
-        yield* DatabaseService.add(
+        yield* Database.add(
           Obj.make(Organization.Organization, {
             name: 'BlueYard',
             website: 'https://blueyard.com',
           }),
         );
-        yield* DatabaseService.flush({ indexes: true });
+        yield* Database.flush({ indexes: true });
         const result = yield* FunctionInvocationService.invokeFunction(research, {
           query: 'Founders and portfolio of BlueYard.',
         });
@@ -90,10 +60,10 @@ describe('Research', () => {
         console.log(inspect(result, { depth: null, colors: true }));
         console.log(JSON.stringify(result, null, 2));
 
-        yield* DatabaseService.flush({ indexes: true });
-        const researchGraph = yield* queryResearchGraph();
+        yield* Database.flush({ indexes: true });
+        const researchGraph = yield* ResearchGraph.query();
         if (researchGraph) {
-          const data = yield* DatabaseService.load(researchGraph.queue).pipe(
+          const data = yield* Database.load(researchGraph.queue).pipe(
             Effect.flatMap((queue) => Effect.promise(() => queue.queryObjects())),
           );
           console.log(inspect(data, { depth: null, colors: true }));
@@ -109,7 +79,7 @@ describe('Research', () => {
     'create and update research report',
     Effect.fnUntraced(
       function* (_) {
-        const organization = yield* DatabaseService.add(
+        const organization = yield* Database.add(
           Obj.make(Organization.Organization, {
             name: 'BlueYard',
             website: 'https://blueyard.com',
@@ -117,11 +87,11 @@ describe('Research', () => {
         );
 
         const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation(queue));
+        const conversation = yield* acquireReleaseResource(() => new AiConversation({ queue }));
 
-        yield* DatabaseService.flush({ indexes: true });
-        const researchBlueprint = yield* DatabaseService.add(Obj.clone(ResearchBlueprint));
-        const markdownBlueprint = yield* DatabaseService.add(Obj.clone(MarkdownBlueprint));
+        yield* Database.flush({ indexes: true });
+        const researchBlueprint = yield* Database.add(Obj.clone(ResearchBlueprint.make()));
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
         yield* Effect.promise(() =>
           conversation.context.bind({
             blueprints: [Ref.make(researchBlueprint), Ref.make(markdownBlueprint)],
@@ -136,18 +106,18 @@ describe('Research', () => {
           prompt: `Create a research summary about ${organization.name}.`,
         });
         {
-          const { objects: docs } = yield* DatabaseService.runQuery(
-            Query.select(Filter.ids(organization.id)).targetOf(HasSubject.HasSubject).source(),
+          const docs = yield* Database.runQuery(
+            Query.select(Filter.id(organization.id)).targetOf(HasSubject.HasSubject).source(),
           );
           if (docs.length !== 1) {
-            throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+            throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => (_ as any).name)}`);
           }
 
           const doc = docs[0];
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* DatabaseService.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
 
@@ -156,18 +126,18 @@ describe('Research', () => {
           prompt: 'Add a section about their portfolio.',
         });
         {
-          const { objects: docs } = yield* DatabaseService.runQuery(
-            Query.select(Filter.ids(organization.id)).targetOf(HasSubject.HasSubject).source(),
+          const docs = yield* Database.runQuery(
+            Query.select(Filter.id(organization.id)).targetOf(HasSubject.HasSubject).source(),
           );
           if (docs.length !== 1) {
-            throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+            throw new Error(`Expected 1 research document; got ${docs.length}: ${docs.map((_) => (_ as any).name)}`);
           }
 
           const doc = docs[0];
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* DatabaseService.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
       },

package/src/{functions/research → blueprints/research/functions}/research.ts

@@ -13,32 +13,26 @@ import * as Schema from 'effect/Schema';
 import * as String from 'effect/String';
 
 import { AiService, ConsolePrinter } from '@dxos/ai';
-import {
-  AiSession,
-  GenerationObserver,
-  createToolkit,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
-} from '@dxos/assistant';
+import { GenericToolkit } from '@dxos/ai';
+import { AiSession, GenerationObserver, ToolExecutionServices, createToolkit } from '@dxos/assistant';
 import { Template } from '@dxos/blueprints';
-import { type DXN, Obj } from '@dxos/echo';
-import { DatabaseService, TracingService, defineFunction } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTestMocked } from '@dxos/functions-runtime/testing';
+import { type DXN, Entity, Obj } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { TracingService, defineFunction } from '@dxos/functions';
 import { type Message, Person } from '@dxos/types';
 import { trim } from '@dxos/util';
 
-import { LocalSearchHandler, LocalSearchToolkit, makeGraphWriterHandler, makeGraphWriterToolkit } from '../../crud';
-import { exaFunction, exaMockFunction } from '../exa';
+import { LocalSearchHandler, LocalSearchToolkit, makeGraphWriterHandler, makeGraphWriterToolkit } from '../../../crud';
+import { ResearchGraph } from '../types';
+import { ResearchDataTypes } from '../types';
 
-import { contextQueueLayerFromResearchGraph } from './research-graph';
 import PROMPT from './research-instructions.tpl?raw';
-import { ResearchDataTypes } from './types';
 
 /**
  * Exec external service and return the results as a Subgraph.
  */
 export default defineFunction({
-  key: 'dxos.org/function/research',
+  key: 'org.dxos.function.research',
   name: 'Research',
   description: trim`
     Search the web to research information about the given subject.
@@ -84,7 +78,7 @@ export default defineFunction({
   handler: Effect.fnUntraced(
     function* ({ data: { query, instructions, mockSearch = false, entityExtraction = false } }) {
       if (mockSearch) {
-        const mockPerson = yield* DatabaseService.add(
+        const mockPerson = yield* Database.add(
           Obj.make(Person.Person, {
             preferredName: 'John Doe',
             emails: [{ value: 'john.doe@example.com' }],
@@ -101,7 +95,7 @@ export default defineFunction({
         };
       }
 
-      yield* DatabaseService.flush({ indexes: true });
+      yield* Database.flush({ indexes: true });
       yield* TracingService.emitStatus({ message: 'Starting research...' });
 
       const NativeWebSearch = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
@@ -118,13 +112,11 @@ export default defineFunction({
 
         toolkit = Toolkit.merge(toolkit, LocalSearchToolkit, GraphWriterToolkit);
         handlers = Layer.mergeAll(handlers, LocalSearchHandler, GraphWriterHandler).pipe(
-          Layer.provide(contextQueueLayerFromResearchGraph),
+          Layer.provide(ResearchGraph.contextQueueLayer),
         ) as any;
       }
 
-      const finishedToolkit = yield* createToolkit({
-        toolkit: toolkit as any,
-      }).pipe(Effect.provide(handlers));
+      const finishedToolkit = yield* createToolkit({ toolkit }).pipe(Effect.provide(handlers));
 
       const session = new AiSession();
       const result = yield* session.run({
@@ -137,8 +129,8 @@ export default defineFunction({
         observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'research' })),
       });
 
-      const objects = yield* Effect.forEach(objectDXNs, (dxn) => DatabaseService.resolve(dxn)).pipe(
-        Effect.map(Array.map((obj) => Obj.toJSON(obj))),
+      const objects = yield* Effect.forEach(objectDXNs, (dxn) => Database.resolve(dxn)).pipe(
+        Effect.map(Array.map((obj) => Entity.toJSON(obj))),
       );
 
       return {
@@ -147,16 +139,9 @@ export default defineFunction({
       };
     },
     Effect.provide(
-      Layer.mergeAll(
-        AiService.model('@anthropic/claude-sonnet-4-0'),
-        // TODO(dmaretskyi): Extract.
-        makeToolResolverFromFunctions([exaFunction, exaMockFunction], Toolkit.make()),
-        makeToolExecutionServiceFromFunctions(Toolkit.make() as any, Layer.empty as any),
-      ).pipe(
-        Layer.provide(
-          // TODO(dmaretskyi): This should be provided by environment.
-          Layer.mergeAll(FunctionInvocationServiceLayerTestMocked({ functions: [exaFunction, exaMockFunction] })),
-        ),
+      AiService.model('@anthropic/claude-sonnet-4-0').pipe(
+        Layer.merge(ToolExecutionServices),
+        Layer.provide(GenericToolkit.providerEmpty),
       ),
     ),
   ),
@@ -178,7 +163,7 @@ const extractLastTextBlock = (result: Message.Message[]) => {
       Function.flow(
         (_: Message.Message) => _.blocks,
         Array.reverse,
-        Array.dropWhile((_: any) => _._tag === 'summary'),
+        Array.dropWhile((_: any) => _._tag === 'stats'),
         Array.takeWhile((_: any) => _._tag === 'text'),
         Array.reverse,
         Array.map((_: any) => _.text),

package/src/blueprints/research/index.ts

@@ -2,6 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-import blueprint from './research-blueprint';
-
-export default blueprint;
+export { default as ResearchBlueprint } from './blueprint';
+export * from './types';

package/src/blueprints/research/types/ResearchGraph.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+
+import { Database, Obj, Query, Ref, Type } from '@dxos/echo';
+import { SystemTypeAnnotation } from '@dxos/echo/internal';
+import { Queue } from '@dxos/echo-db';
+import { ContextQueueService, QueueService } from '@dxos/functions';
+
+/**
+ * Container for a set of ephemeral research results.
+ */
+export const ResearchGraph = Schema.Struct({
+  queue: Ref.Ref(Queue),
+}).pipe(
+  Type.object({
+    typename: 'org.dxos.type.research-graph',
+    version: '0.1.0',
+  }),
+  SystemTypeAnnotation.set(true),
+);
+
+export interface ResearchGraph extends Schema.Schema.Type<typeof ResearchGraph> {}
+
+export const create: () => Effect.Effect<ResearchGraph, never, Database.Service | QueueService> = Effect.fn(
+  'createResearchGraph',
+)(function* () {
+  const queue = yield* QueueService.createQueue();
+  return yield* Database.add(Obj.make(ResearchGraph, { queue: Ref.fromDXN(queue.dxn) }));
+});
+
+export const query: () => Effect.Effect<ResearchGraph | undefined, never, Database.Service> = Effect.fn(
+  'queryResearchGraph',
+)(function* () {
+  const objects = yield* Database.runQuery(Query.type(ResearchGraph));
+  return objects.at(0);
+});
+
+export const contextQueueLayer = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const researchGraph = (yield* query()) ?? (yield* create());
+    const researchQueue = yield* Database.load(researchGraph.queue);
+    return ContextQueueService.layer(researchQueue);
+  }),
+);

package/src/{functions/research/types.ts → blueprints/research/types/index.ts}

@@ -1,26 +1,32 @@
 //
-// Copyright 2025 DXOS.org
+// Copyright 2026 DXOS.org
 //
 
 import { type Type } from '@dxos/echo';
 import { Text } from '@dxos/schema';
-import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson, Project, Task } from '@dxos/types';
+import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson, Pipeline, Task } from '@dxos/types';
+
+export * as ResearchGraph from './ResearchGraph';
 
 /**
  * Data types for research.
  */
-export const ResearchDataTypes: Type.Entity.Any[] = [
+// TODO(burdon): This should not be hardcoded.
+export const ResearchDataTypes: Type.AnyEntity[] = [
   // Objects
   Event.Event,
-  LegacyOrganization,
   Task.Task,
   Text.Text,
 
-  // Relations
   // TODO(wittjosiah): Until views (e.g., Table) support relations this needs to be expressed via organization ref.
   // Employer.Employer,
+  // Organization.Organization,
   LegacyPerson,
-  Project.Project,
+  LegacyOrganization,
+
+  Pipeline.Pipeline,
+
+  // Relations
   HasRelationship.HasRelationship,
   HasConnection.HasConnection,
 ];

package/src/blueprints/testing.ts

@@ -2,17 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Toolkit from '@effect/ai/Toolkit';
+import * as Arr from 'effect/Array';
 import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
 
 import { ConsolePrinter } from '@dxos/ai';
-import { type AiConversation, type AiConversationRunParams, GenerationObserver } from '@dxos/assistant';
+import {
+  AiContextService,
+  type AiConversation,
+  type AiConversationRunProps,
+  GenerationObserver,
+} from '@dxos/assistant';
+import type { Blueprint } from '@dxos/blueprints';
+import { Database, Ref } from '@dxos/echo';
+import { type FunctionDefinition } from '@dxos/functions';
 import { log } from '@dxos/log';
 
-export type TestStep = Pick<AiConversationRunParams, 'prompt' | 'system'> & {
+export type TestStep = Pick<AiConversationRunProps, 'prompt' | 'system'> & {
   test?: () => Promise<void>;
 };
 
+/**
+ * Blueprint definition type for testing.
+ * Mirrors AppCapabilities.BlueprintDefinition to avoid circular dependency with app-toolkit.
+ */
+export interface BlueprintDefinition {
+  key: string;
+  functions: FunctionDefinition.Any[];
+  make: () => Blueprint.Blueprint;
+}
+
 /**
  * Runs the prompt steps, calling the test function after each step.
  */
@@ -30,5 +49,17 @@ export const runSteps = Effect.fn(function* (conversation: AiConversation, steps
   }
 });
 
-// TODO(wittjosiah): Don't cast.
-export const testToolkit = Toolkit.empty as Toolkit.Toolkit<any>;
+/**
+ * Binds blueprints from the blueprint definitions.
+ */
+// TODO(dmaretskyi): Potentially the agent will auto-bind the blueprints.
+export const addBlueprints = Effect.fnUntraced(function* (blueprints: BlueprintDefinition[]) {
+  yield* AiContextService.bindContext({
+    blueprints: yield* pipe(
+      blueprints,
+      Arr.map((blueprint) => blueprint.make()),
+      Effect.forEach(Database.add),
+      Effect.map(Arr.map(Ref.make)),
+    ),
+  });
+});

package/src/blueprints/websearch/blueprint.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ToolId } from '@dxos/ai';
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.web-search';
+
+const functions: AppCapabilities.BlueprintDefinition['functions'] = [];
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Web Search',
+    description: 'Search the web.',
+    instructions: {
+      source: Ref.make(Text.make()),
+    },
+    tools: [ToolId.make('AnthropicWebSearch')],
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  functions,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/websearch/index.ts

@@ -2,7 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-import blueprint from './websearch-blueprint';
-
-export { WebSearchToolkit } from './websearch-toolkit';
-export default blueprint;
+export { default as WebSearchBlueprint } from './blueprint';
+export { WebSearchToolkit } from './toolkit';

package/src/crud/graph.test.ts

@@ -2,42 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
-import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
 import { describe, it } from '@effect/vitest';
-import * as Config from 'effect/Config';
 import * as Effect from 'effect/Effect';
-import * as Function from 'effect/Function';
 import * as Layer from 'effect/Layer';
 
-import { AiService, ToolExecutionService, ToolResolverService } from '@dxos/ai';
-import * as AiServiceRouter from '@dxos/ai/AiServiceRouter';
-import { tapHttpErrors } from '@dxos/ai/testing';
 import { AiSession } from '@dxos/assistant';
-import { TestHelpers } from '@dxos/effect';
-import { DatabaseService, TracingService } from '@dxos/functions';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
+import { TestHelpers } from '@dxos/effect/testing';
 import { log } from '@dxos/log';
-import { Project } from '@dxos/types';
+import { Pipeline } from '@dxos/types';
 
 import { makeGraphWriterHandler, makeGraphWriterToolkit } from './graph';
 
-// import { type EchoTestBuilder } from '@dxos/echo-db/testing';
-
-const TestLayer = Function.pipe(
-  AiService.model('@anthropic/claude-3-5-sonnet-20241022'),
-  Layer.provideMerge(DatabaseService.notAvailable),
-  Layer.provideMerge(ToolResolverService.layerEmpty),
-  Layer.provideMerge(ToolExecutionService.layerEmpty),
-  Layer.provide(AiServiceRouter.AiServiceRouter),
-  Layer.provide(
-    AnthropicClient.layerConfig({
-      apiKey: Config.redacted('ANTHROPIC_API_KEY'),
-      transformClient: tapHttpErrors,
-    }),
-  ),
-  Layer.provide(FetchHttpClient.layer),
-  Layer.provideMerge(TracingService.layerNoop),
-);
+const TestLayer = AssistantTestLayer({});
 
 describe('graph', () => {
   // let builder: EchoTestBuilder;
@@ -46,7 +23,7 @@ describe('graph', () => {
   //   const relatedSchemas = await findRelatedSchema(db, Schema.Struct({}));
   // });
 
-  const Toolkit = makeGraphWriterToolkit({ schema: [Project.Project] });
+  const Toolkit = makeGraphWriterToolkit({ schema: [Pipeline.Pipeline] });
   const ToolkitLayer = makeGraphWriterHandler(Toolkit);
 
   it.effect.skip(
@@ -63,7 +40,7 @@ describe('graph', () => {
         log.info('response', { response });
       },
       Effect.provide(Layer.mergeAll(TestLayer, ToolkitLayer)),
-      TestHelpers.runIf(process.env.ANTHROPIC_API_KEY),
+      TestHelpers.provideTestContext,
     ),
   );
 });