@dxos/assistant 0.8.3 → 0.8.4-main.1068cf700f

package/src/session/session.test.ts

@@ -2,18 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
-import { describe, test } from 'vitest';
-
-import { EdgeAiServiceClient, ConsolePrinter, createTool, ToolResult } from '@dxos/ai';
-import { AI_SERVICE_ENDPOINT } from '@dxos/ai/testing';
-import { ArtifactId, defineArtifact } from '@dxos/artifact';
-import { Type, Obj } from '@dxos/echo';
-import { ObjectId } from '@dxos/echo-schema';
-import { DXN } from '@dxos/keys';
+import * as Tool from '@effect/ai/Tool';
+import * as Toolkit from '@effect/ai/Toolkit';
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+
+import { Obj, Type } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
 import { log } from '@dxos/log';
 
-import { AISession } from './session';
+import { AssistantTestLayer } from '../testing';
+
+import { AiSession } from './session';
 
 // Define a calendar event artifact schema.
 const CalendarEventSchema = Schema.Struct({
@@ -22,7 +24,7 @@ const CalendarEventSchema = Schema.Struct({
   endTime: Schema.String,
   description: Schema.String,
 }).pipe(
-  Type.Obj({
+  Type.object({
     typename: 'example.com/type/CalendarEvent',
     version: '0.1.0',
   }),
@@ -30,132 +32,103 @@ const CalendarEventSchema = Schema.Struct({
 
 type CalendarEvent = Schema.Schema.Type<typeof CalendarEventSchema>;
 
-// TODO(burdon): Flaky.
-describe.skip('AISession with Ollama', () => {
-  test('create calendar itinerary', { timeout: 60_000 }, async () => {
-    const aiClient = new EdgeAiServiceClient({ endpoint: AI_SERVICE_ENDPOINT.REMOTE });
-    // const aiClient = new OllamaAiServiceClient({
-    //   overrides: { model: 'llama3.1:8b' },
-    // });
-    const session = new AISession({ operationModel: 'configured' });
-
-    const objects = new Set<string>();
-
-    // Define calendar artifact.
-    const calendarArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/calendar',
-      name: 'Calendar',
-      instructions: 'Use this to create and query calendar events.',
-      schema: CalendarEventSchema,
-      tools: [
-        createTool('calendar', {
-          name: 'query',
-          description: 'Query the calendar for events',
-          schema: Schema.Struct({}),
-          execute: async () => {
-            return ToolResult.Success(CALENDAR_EVENTS);
-          },
-        }),
-      ],
-    });
-
-    const tableArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/table',
-      name: 'Table',
-      instructions: 'Use this to create and manage tables. Each table has a unique id.',
-      schema: Schema.Struct({}),
-      tools: [
-        createTool('table', {
-          name: 'create',
-          description: 'Create a table',
-          schema: Schema.Struct({
-            data: Schema.Array(Schema.Any).annotations({ description: 'Array of data payloads to add as rows' }),
-          }),
-          execute: async ({ data }) => {
-            log('create table', { data });
-            const id = DXN.fromLocalObjectId(ObjectId.random()).toString();
-            objects.add(id);
-            // TODO(dmaretskyi): consider xml for refs instead of @dxn:echo:@:XXXXX
-            return ToolResult.Success(`table @${id}`);
-          },
-        }),
-      ],
-    });
-
-    const mapArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/map',
-      name: 'Map',
-      instructions:
-        'Use this to create and manage maps. Maps source data from tables. Table id is required to create a map.',
-      schema: Schema.Struct({}),
-      tools: [
-        createTool('map', {
-          name: 'create',
-          description: 'Create a map',
-          schema: Schema.Struct({
-            source: ArtifactId.annotations({
-              description: 'The table that will be used as the source of the map',
-            }),
-          }),
-          execute: async ({ source }) => {
-            // TODO(dmaretskyi): Use effect-schema decode instead of manual parsing.
-            const sourceId = ArtifactId.toDXN(source);
-            if (!objects.has(sourceId.toString())) {
-              return ToolResult.Error(`table id=${source} not found`);
-            }
-            log('create map', { sourceId });
-            const id = DXN.fromLocalObjectId(ObjectId.random()).toString();
-            objects.add(id);
-            // TODO(dmaretskyi): consider xml for refs instead of @dxn:echo:@:XXXXX
-            return ToolResult.Success(`map @${id}`);
-          },
-        }),
-      ],
-    });
-
-    const scriptArtifact = defineArtifact({
-      id: 'artifact:dxos.org/plugin/script',
-      name: 'Script',
-      instructions: 'Use this to create and manage scripts',
-      schema: Schema.Struct({}),
-      tools: [],
-    });
-
-    // session.streamEvent.on((event) => {
-    //   printStreamEvent(event);
-    // });
-
-    const printer = new ConsolePrinter();
-    session.message.on((message) => printer.printMessage(message));
-    session.userMessage.on((message) => printer.printMessage(message));
-    session.block.on((block) => printer.printContentBlock(block));
-
-    // session.update.on((update) => {
-    //   log('update', { update });
-    // });
-
-    // Test creating an itinerary
-    const response = await session.run({
-      client: aiClient,
-      tools: [],
-      artifacts: [calendarArtifact, tableArtifact, mapArtifact, scriptArtifact],
-      requiredArtifactIds: [calendarArtifact.id, tableArtifact.id, mapArtifact.id, scriptArtifact.id],
-      history: [],
-      generationOptions: {
-        model: '@anthropic/claude-3-5-haiku-20241022',
+const TestToolkit = Toolkit.make(
+  Tool.make('Calculator', {
+    description: 'Basic calculator tool',
+    parameters: {
+      input: Schema.String.annotations({
+        description: 'The calculation to perform.',
+      }),
+    },
+    success: Schema.Struct({
+      result: Schema.Number,
+    }),
+    failure: Schema.Never,
+  }),
+);
+
+// Tool handlers.
+const toolkitLayer = TestToolkit.toLayer({
+  Calculator: ({ input }) =>
+    Effect.gen(function* () {
+      const result = (() => {
+        // Restrict to basic arithmetic operations for safety.
+        const sanitizedInput = input.replace(/[^0-9+\-*/().\s]/g, '');
+        log.info('calculate', { sanitizedInput });
+
+        // eslint-disable-next-line @typescript-eslint/no-implied-eval
+        return Function(`"use strict"; return (${sanitizedInput})`)();
+      })();
+
+      return { result };
+    }),
+});
+
+const TestLayer = Layer.mergeAll(
+  AssistantTestLayer({
+    types: [CalendarEventSchema],
+  }),
+  toolkitLayer,
+);
+
+describe('AiSession', () => {
+  it.effect(
+    'no tools',
+    Effect.fnUntraced(
+      function* (_) {
+        const session = new AiSession({ operationModel: 'configured' });
+        const response = yield* session.run({
+          prompt: 'Hello world!',
+          history: [],
+        });
+        log.info('response', { response });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'calculator',
+    Effect.fnUntraced(
+      function* (_) {
+        const session = new AiSession({ operationModel: 'configured' });
+        const toolkit = yield* TestToolkit;
+        const response = yield* session.run({
+          toolkit,
+          prompt: 'What is 10 + 30?',
+          history: [],
+        });
+        log.info('response', { response });
       },
-      prompt: 'create a table and map for a travel itinerary based on events in my calendar',
-    });
-
-    log('result', {
-      objects,
-      finalMessage: response.at(-1),
-    });
-  });
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'tool schema error',
+    Effect.fnUntraced(
+      function* (_) {
+        const session = new AiSession({ operationModel: 'configured' });
+        const toolkit = yield* TestToolkit;
+        const response = yield* session.run({
+          toolkit,
+          prompt:
+            'I am testing error handling in tool paramter parsing. I want you to call the calculator tool but omit the input parameter to intentionally differ from the tool schema.',
+          history: [],
+        });
+        log.info('response', { response });
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
 });
 
 // Travel to rome, florence, livorno, siena, madrid for conferences
-const CALENDAR_EVENTS: CalendarEvent[] = [
+
+const _CALENDAR_EVENTS: CalendarEvent[] = [
   Obj.make(CalendarEventSchema, {
     title: 'Exploring Ancient Ruins in Rome',
     startTime: '2024-01-01T10:00:00Z',
@@ -187,43 +160,3 @@ const CALENDAR_EVENTS: CalendarEvent[] = [
     description: 'Travel to Madrid',
   }),
 ];
-
-// const printStreamEvent = (event: GenerationStreamEvent) => {
-//   switch (event.type) {
-//     case 'message_start': {
-//       process.stdout.write(`${event.message.role.toUpperCase()}\n\n`);
-//       for (const content of event.message.content) {
-//         printContentBlock(content);
-//       }
-//       break;
-//     }
-//     case 'content_block_start': {
-//       printContentBlock(event.content);
-//       break;
-//     }
-//     case 'content_block_delta': {
-//       switch (event.delta.type) {
-//         case 'text_delta': {
-//           process.stdout.write(event.delta.text);
-//           break;
-//         }
-//         case 'input_json_delta': {
-//           process.stdout.write(event.delta.partial_json);
-//           break;
-//         }
-//       }
-//       break;
-//     }
-//     case 'content_block_stop': {
-//       process.stdout.write('\n');
-//       break;
-//     }
-//     case 'message_delta': {
-//       break;
-//     }
-//     case 'message_stop': {
-//       process.stdout.write('\n\n');
-//       break;
-//     }
-//   }
-// };