@dxos/plugin-markdown 0.8.4-main.bc674ce → 0.8.4-main.c351d160a8

package/src/blueprints/functions/create.test.ts

@@ -6,58 +6,32 @@ import { describe, expect, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { AiService, ConsolePrinter } from '@dxos/ai';
-import { MemoizedAiService, TestAiService } from '@dxos/ai/testing';
-import {
-  AiConversation,
-  type ContextBinding,
-  GenerationObserver,
-  makeToolExecutionServiceFromFunctions,
-  makeToolResolverFromFunctions,
-} from '@dxos/assistant';
+import { MemoizedAiService } from '@dxos/ai/testing';
+import { AiContextService, AiConversationService } from '@dxos/assistant';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
 import { Blueprint } from '@dxos/blueprints';
 import { SpaceProperties } from '@dxos/client-protocol';
 import { DXN, Database, Obj, Query, Ref } from '@dxos/echo';
-import { acquireReleaseResource } from '@dxos/effect';
+import { Collection } from '@dxos/echo';
 import { TestHelpers } from '@dxos/effect/testing';
-import { CredentialsService, FunctionInvocationService, QueueService, TracingService } from '@dxos/functions';
-import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
+import { FunctionInvocationService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { ObjectId } from '@dxos/keys';
 import { Markdown } from '@dxos/plugin-markdown/types';
-import { Collection } from '@dxos/schema';
-import { HasSubject, type Message } from '@dxos/types';
+import { HasSubject } from '@dxos/types';
 
-import { WithProperties, testToolkit } from '../../testing';
-import * as MarkdownBlueprint from '../markdown-blueprint';
+import { WithProperties } from '../../testing';
+import MarkdownBlueprint from '../markdown-blueprint';
 
 import create from './create';
 
 ObjectId.dangerouslyDisableRandomness();
 
-const TestLayer = Layer.mergeAll(
-  AiService.model('@anthropic/claude-opus-4-0'),
-  makeToolResolverFromFunctions(MarkdownBlueprint.functions, testToolkit),
-  makeToolExecutionServiceFromFunctions(testToolkit, testToolkit.toLayer({}) as any),
-).pipe(
-  Layer.provideMerge(
-    FunctionInvocationServiceLayerTest({
-      functions: MarkdownBlueprint.functions,
-    }),
-  ),
-  Layer.provideMerge(
-    Layer.mergeAll(
-      TestAiService(),
-      TestDatabaseLayer({
-        spaceKey: 'fixed',
-        indexing: { vector: true },
-        types: [SpaceProperties, Collection.Collection, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
-      }),
-      CredentialsService.configuredLayer([]),
-      TracingService.layerNoop,
-    ),
-  ),
-);
+const TestLayer = AssistantTestLayer({
+  functions: [...MarkdownBlueprint.functions],
+  types: [SpaceProperties, Collection.Collection, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
+  tracing: 'pretty',
+});
 
 describe('create', () => {
   it.effect(
@@ -71,9 +45,9 @@ describe('create', () => {
           content,
         });
 
-        const doc = yield* Database.Service.resolve(DXN.parse(result.id), Markdown.Document);
+        const doc = yield* Database.resolve(DXN.parse(result.id), Markdown.Document);
         expect(doc.name).toBe(name);
-        const text = yield* Database.Service.load(doc.content);
+        const text = yield* Database.load(doc.content);
         expect(text.content).toBe(content);
       },
       WithProperties,
@@ -86,24 +60,17 @@ describe('create', () => {
     'create a markdown document',
     Effect.fnUntraced(
       function* (_) {
-        const queue = yield* QueueService.createQueue<Message.Message | ContextBinding>();
-        const conversation = yield* acquireReleaseResource(() => new AiConversation({ queue }));
-
-        yield* Database.Service.flush({ indexes: true });
-        const markdownBlueprint = yield* Database.Service.add(Obj.clone(MarkdownBlueprint.make()));
-        yield* Effect.promise(() =>
-          conversation.context.bind({
-            blueprints: [Ref.make(markdownBlueprint)],
-          }),
-        );
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
+        yield* AiContextService.bindContext({
+          blueprints: [Ref.make(markdownBlueprint)],
+        });
 
-        const observer = GenerationObserver.fromPrinter(new ConsolePrinter());
-        yield* conversation.createRequest({
-          observer,
+        yield* AiConversationService.run({
           prompt: `Create a document with a cookie recipe.`,
         });
+
         {
-          const docs = yield* Database.Service.runQuery(Query.type(Markdown.Document));
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
           if (docs.length !== 1) {
             throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
           }
@@ -112,12 +79,12 @@ describe('create', () => {
           invariant(Obj.instanceOf(Markdown.Document, doc));
           console.log({
             name: doc.name,
-            content: yield* Database.Service.load(doc.content).pipe(Effect.map((_) => _.content)),
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
           });
         }
       },
       WithProperties,
-      Effect.provide(TestLayer),
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
       TestHelpers.provideTestContext,
     ),
     MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,

package/src/blueprints/functions/create.ts

@@ -5,15 +5,14 @@
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { ArtifactId } from '@dxos/assistant';
 import { Obj } from '@dxos/echo';
 import { defineFunction } from '@dxos/functions';
-import { Collection } from '@dxos/schema';
+import { CollectionModel } from '@dxos/schema';
 
 import { Markdown } from '../../types';
 
 export default defineFunction({
-  key: 'dxos.org/function/markdown/create',
+  key: 'org.dxos.function.markdown.create',
   name: 'Create',
   description: 'Creates a new markdown document and adds it to the space.',
   inputSchema: Schema.Struct({
@@ -21,11 +20,13 @@ export default defineFunction({
     content: Schema.String,
   }),
   outputSchema: Schema.Struct({
-    id: ArtifactId,
+    id: Schema.String.annotations({
+      description: 'The DXN of the created document.',
+    }),
   }),
   handler: Effect.fn(function* ({ data: { name, content } }) {
     const object = Markdown.make({ name, content });
-    yield* Collection.add({ object });
+    yield* CollectionModel.add({ object });
 
     return {
       id: Obj.getDXN(object).toString(),

package/src/blueprints/functions/index.ts

@@ -2,6 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-export { default as create } from './create';
-export { default as open } from './open';
-export { default as update } from './update';
+import Create from './create';
+import Open from './open';
+import Update from './update';
+
+export { Create, Open, Update };
+
+export const MarkdownFunctions = {
+  Create,
+  Open,
+  Update,
+};

package/src/blueprints/functions/open.ts

@@ -5,29 +5,29 @@
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { ArtifactId } from '@dxos/assistant';
-import { Database } from '@dxos/echo';
+import { Database, Ref } from '@dxos/echo';
 import { defineFunction } from '@dxos/functions';
 
 import { Markdown } from '../../types';
 
 export default defineFunction({
-  key: 'dxos.org/function/markdown/open',
+  key: 'org.dxos.function.markdown.open',
   name: 'Open',
   description: 'Opens and reads the contents of a new markdown document.',
   inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
+    doc: Ref.Ref(Markdown.Document).annotations({
       description: 'The ID of the markdown document.',
     }),
   }),
   outputSchema: Schema.Struct({
     content: Schema.String,
   }),
-  handler: Effect.fn(function* ({ data: { id } }) {
-    const object = yield* Database.Service.resolve(ArtifactId.toDXN(id), Markdown.Document);
-    const { content } = yield* Effect.promise(() => object.content.load());
-    return {
-      content,
-    };
+  handler: Effect.fn(function* ({ data: { doc } }) {
+    const { content } = yield* doc.pipe(
+      Database.load,
+      Effect.map((_) => _.content),
+      Effect.flatMap(Database.load),
+    );
+    return { content };
   }),
 });