@dxos/assistant 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/src/session/session.test.ts

@@ -1,190 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
-import { describe, expect, 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 { Message } from '@dxos/types';
-
-import { AssistantTestLayer } from '../testing';
-import { AiSession } from './session';
-
-// Define a calendar event artifact schema.
-const CalendarEventSchema = Schema.Struct({
-  title: Schema.String,
-  startTime: Schema.String,
-  endTime: Schema.String,
-  description: Schema.String,
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.calendar-event',
-    version: '0.1.0',
-  }),
-);
-
-type CalendarEvent = Schema.Schema.Type<typeof CalendarEventSchema>;
-
-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],
-    tracing: 'pretty',
-  }),
-  toolkitLayer,
-);
-
-describe('AiSession', () => {
-  it.effect(
-    'no tools',
-    Effect.fnUntraced(
-      function* (_) {
-        const session = new AiSession();
-        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();
-        const toolkit = yield* TestToolkit;
-        const response = yield* session.run({
-          toolkit,
-          prompt: 'What is 10 + 30?',
-          history: [],
-        });
-        log.info('response', { response });
-      },
-      Effect.provide(TestLayer),
-      TestHelpers.provideTestContext,
-    ),
-  );
-
-  it.effect(
-    'tool schema error',
-    Effect.fnUntraced(
-      function* (_) {
-        const session = new AiSession();
-        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,
-    ),
-  );
-
-  it.effect(
-    'summarization',
-    Effect.fnUntraced(
-      function* (_) {
-        const session = new AiSession({ summarizationThreshold: 0 }); // Force summarization.
-        const response = yield* session.run({
-          prompt: 'What did we talk about?',
-          history: [
-            Obj.make(Message.Message, {
-              created: '2024-01-01T10:00:00Z',
-              sender: { role: 'user' },
-              blocks: [{ _tag: 'text', text: 'How many apples are in the basket?' }],
-            }),
-            Obj.make(Message.Message, {
-              created: '2024-01-01T11:00:00Z',
-              sender: { role: 'assistant' },
-              blocks: [{ _tag: 'text', text: 'There are 10 apples in the basket.' }],
-            }),
-          ],
-        });
-        expect(response).toBeDefined();
-      },
-      Effect.provide(TestLayer),
-      TestHelpers.provideTestContext,
-    ),
-  );
-});
-
-// Travel to rome, florence, livorno, siena, madrid for conferences
-
-const _CALENDAR_EVENTS: CalendarEvent[] = [
-  Obj.make(CalendarEventSchema, {
-    title: 'Exploring Ancient Ruins in Rome',
-    startTime: '2024-01-01T10:00:00Z',
-    endTime: '2024-01-01T11:00:00Z',
-    description: 'Tech conference at the historic Colosseum with networking opportunities',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Renaissance Tech Summit in Florence',
-    startTime: '2024-01-01T11:00:00Z',
-    endTime: '2024-01-01T12:00:00Z',
-    description: 'Discussing AI innovations surrounded by Renaissance art',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Livorno',
-    startTime: '2024-01-01T12:00:00Z',
-    endTime: '2024-01-01T13:00:00Z',
-    description: 'Travel to Livorno',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Siena',
-    startTime: '2024-01-01T13:00:00Z',
-    endTime: '2024-01-01T14:00:00Z',
-    description: 'Travel to Siena',
-  }),
-  Obj.make(CalendarEventSchema, {
-    title: 'Travel to Madrid',
-    startTime: '2024-01-01T14:00:00Z',
-    endTime: '2024-01-01T15:00:00Z',
-    description: 'Travel to Madrid',
-  }),
-];

package/src/testing/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-export * from './layer';

package/src/testing/layer.ts

@@ -1,259 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import { Registry } from '@effect-atom/atom';
-import * as LanguageModel from '@effect/ai/LanguageModel';
-import * as KeyValueStore from '@effect/platform/KeyValueStore';
-import * as Array from 'effect/Array';
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Match from 'effect/Match';
-
-import {
-  AiService,
-  ConsolePrinter,
-  GenericToolkit,
-  type ModelName,
-  type ToolExecutionService,
-  type ToolResolverService,
-} from '@dxos/ai';
-import { TestAiService } from '@dxos/ai/testing';
-import { Blueprint, Prompt } from '@dxos/blueprints';
-import { Database, DXN, Feed, Type } from '@dxos/echo';
-import { acquireReleaseResource } from '@dxos/effect';
-import type { TestContextService } from '@dxos/effect/testing';
-import {
-  CredentialsService,
-  FunctionInvocationService,
-  QueueService,
-  type ServiceCredential,
-  ServiceNotAvailableError,
-  Trace,
-  TracingService,
-} from '@dxos/functions';
-import {
-  Process,
-  ProcessManager,
-  ServiceResolver,
-  TracingServiceExt,
-  TriggerDispatcher,
-  TriggerStateStore,
-} from '@dxos/functions-runtime';
-import { FunctionInvocationServiceLayerTest, TestDatabaseLayer } from '@dxos/functions-runtime/testing';
-import { Operation, OperationHandlerSet, OperationRegistry } from '@dxos/operation';
-
-import { AiContextBinder, AiContextService, AiConversation, AiConversationService } from '../conversation';
-import { ToolExecutionServices } from '../functions';
-import { AgentService } from '../service';
-import { CompleteBlock } from '../tracing';
-
-interface TestLayerOptions {
-  aiServicePreset?: 'direct' | 'edge-local' | 'edge-remote';
-  model?: ModelName;
-  operationHandlers?: OperationHandlerSet.OperationHandlerSet | OperationHandlerSet.OperationHandlerSet[];
-  toolkits?: GenericToolkit.GenericToolkit[];
-  types?: Type.AnyEntity[];
-  blueprints?: Blueprint.Blueprint[];
-  credentials?: ServiceCredential[];
-  /*
-   * Tracing configuration.
-   * @default 'noop'
-   */
-  tracing?: 'noop' | 'console' | 'pretty';
-
-  disableLlmMemoization?: boolean;
-
-  /**
-   * Core system prompt for the agent.
-   */
-  systemPrompt?: string;
-}
-
-export type AssistantTestServices =
-  // Convinience
-  | LanguageModel.LanguageModel
-  | Feed.FeedService
-  | CredentialsService
-  | AgentService.AgentService
-  | AiService.AiService
-  | Database.Service
-  | QueueService
-  // Registries
-  | Blueprint.RegistryService
-  | OperationRegistry.Service
-  | GenericToolkit.GenericToolkitProvider
-  | Operation.Service
-  // Core
-  | ProcessManager.ProcessManagerService
-  | Process.ProcessMonitorService
-  | Registry.AtomRegistry
-  // Should those be here?
-  | OperationHandlerSet.OperationHandlerProvider
-  | KeyValueStore.KeyValueStore
-  | ServiceResolver.ServiceResolver
-  | TracingService
-  | Trace.TraceService
-  | Trace.TraceSink
-  // Deprecated
-  | ToolExecutionService
-  | ToolResolverService
-  | FunctionInvocationService;
-
-export const AssistantTestLayer = ({
-  aiServicePreset = 'direct',
-  model = '@anthropic/claude-opus-4-6',
-  operationHandlers = [],
-  toolkits = [],
-  types = [],
-  credentials = [],
-  tracing = 'noop',
-  disableLlmMemoization = false,
-  blueprints = [],
-  systemPrompt,
-}: TestLayerOptions = {}): Layer.Layer<AssistantTestServices, never, TestContextService> => {
-  const toolkit = GenericToolkit.merge(...toolkits);
-  const operationHandlersSet = Array.isArray(operationHandlers)
-    ? OperationHandlerSet.merge(...operationHandlers)
-    : operationHandlers;
-  types.push(Blueprint.Blueprint, Prompt.Prompt, Operation.PersistentOperation, Feed.Feed);
-  types = Array.dedupeWith(types, (a, b) => Type.getTypename(a) === Type.getTypename(b));
-
-  return Layer.empty.pipe(
-    Layer.provideMerge(ProcessManager.ProcessOperationInvoker.layer),
-    Layer.provideMerge(Trace.testTraceService({ meta: { processName: 'test' } })),
-    Layer.provideMerge(AgentService.layer({ systemPrompt })),
-    Layer.provideMerge(ProcessManager.layer({ idGenerator: ProcessManager.SequentialProcessIdGenerator })),
-    Layer.provideMerge(
-      // TODO(dmaretskyi): Refactor to be able to merge resovler layers, also consider service mesh achitecture.
-      Layer.effect(
-        ServiceResolver.ServiceResolver,
-        Effect.gen(function* () {
-          const services = yield* Effect.context<Database.Service | Feed.FeedService>().pipe(
-            Effect.map(Context.pick(Database.Service, Feed.FeedService)),
-            Effect.map(Layer.succeedContext),
-          );
-          // AiContextBinder.
-          return ServiceResolver.compose(
-            ServiceResolver.succeed(AiContextService, (context) =>
-              Effect.gen(function* () {
-                if (!context.conversation) {
-                  return yield* Effect.fail(new ServiceNotAvailableError(AiContextService.key));
-                }
-                const feed = yield* Database.resolve(DXN.parse(context.conversation), Feed.Feed).pipe(Effect.orDie);
-                const runtime = yield* Effect.runtime<Feed.FeedService>();
-                const binder = yield* acquireReleaseResource(
-                  () =>
-                    new AiContextBinder({
-                      feed,
-                      runtime,
-                    }),
-                );
-                return { binder };
-              }).pipe(Effect.provide(services)),
-            ),
-            // AiConversationService.
-            ServiceResolver.succeed(AiConversationService, (context) =>
-              Effect.gen(function* () {
-                if (!context.conversation) {
-                  return yield* Effect.fail(new ServiceNotAvailableError(AiConversationService.key));
-                }
-                const feed = yield* Database.resolve(DXN.parse(context.conversation), Feed.Feed).pipe(Effect.orDie);
-                const runtime = yield* Effect.runtime<Feed.FeedService>();
-                const conversation = yield* acquireReleaseResource(
-                  () =>
-                    new AiConversation({
-                      feed,
-                      runtime,
-                    }),
-                );
-                return conversation;
-              }).pipe(Effect.provide(services)),
-            ),
-            yield* ServiceResolver.fromRequirements(
-              Database.Service,
-              GenericToolkit.GenericToolkitProvider,
-              Feed.FeedService,
-              AiService.AiService,
-              OperationRegistry.Service,
-              Blueprint.RegistryService,
-              FunctionInvocationService,
-              QueueService,
-            ),
-          );
-        }),
-      ),
-    ),
-    Layer.provideMerge(Layer.mergeAll(OperationRegistry.layer, AiService.model(model), ToolExecutionServices)),
-    Layer.provideMerge(
-      FunctionInvocationServiceLayerTest({
-        functions: operationHandlersSet,
-      }),
-    ),
-    Layer.provideMerge(
-      Layer.mergeAll(
-        TestAiService({ preset: aiServicePreset, disableMemoization: disableLlmMemoization }),
-        TestDatabaseLayer({
-          spaceKey: 'fixed',
-          types,
-        }),
-        CredentialsService.configuredLayer(credentials),
-        Match.value(tracing).pipe(
-          Match.when('noop', () => TracingService.layerNoop),
-          Match.when('console', () => TracingServiceExt.layerLogInfo()),
-          Match.when('pretty', () =>
-            TracingServiceExt.layerConsolePrettyPrint({
-              toolkit: (toolkits.length > 0 ? GenericToolkit.merge(...toolkits) : GenericToolkit.empty).toolkit as any,
-            }),
-          ),
-          Match.exhaustive,
-        ),
-        Match.value(tracing).pipe(
-          Match.when('noop', () => Trace.layerNoop),
-          Match.when('console', () => Trace.layerConsole),
-          Match.when('pretty', () => TraceSinkPretty()),
-          Match.exhaustive,
-        ),
-      ),
-    ),
-    Layer.provideMerge(Layer.succeed(Blueprint.RegistryService, new Blueprint.Registry(blueprints))),
-    Layer.provideMerge(GenericToolkit.providerLayer(toolkit)),
-    Layer.provideMerge(OperationHandlerSet.provide(operationHandlersSet)),
-    Layer.provideMerge(KeyValueStore.layerMemory),
-    Layer.provideMerge(Registry.layer),
-    Layer.orDie,
-  );
-};
-
-interface TestLayerWithTriggersOptions extends TestLayerOptions {}
-
-export type AssistantTestServicesWithTriggers = AssistantTestServices | TriggerDispatcher | TriggerStateStore;
-
-export const AssistantTestLayerWithTriggers = (
-  options: TestLayerWithTriggersOptions,
-): Layer.Layer<AssistantTestServicesWithTriggers, never, TestContextService> =>
-  Layer.mergeAll(
-    AssistantTestLayer(options),
-    TriggerDispatcher.layer({ timeControl: 'manual', startingTime: new Date('2025-09-05T15:01:00.000Z') }).pipe(
-      Layer.provide(Registry.layer),
-    ),
-    TriggerStateStore.layerMemory,
-  ) as any;
-
-const TraceSinkPretty = () =>
-  Layer.succeed(Trace.TraceSink, {
-    write: (message) => {
-      for (const event of message.events) {
-        if (Trace.isOfType(CompleteBlock, event)) {
-          const tag = message.meta.processName ?? `[${message.meta.pid ?? 'unknown'}]`;
-          console.log(`[${tag}] ${event.data.role.toUpperCase()}`);
-          new ConsolePrinter({ tag }).printContentBlock(event.data.block);
-        } else if (Trace.isOfType(Process.SpawnedEvent, event)) {
-          console.log(`[${message.meta.pid}] Process spawned: ${message.meta.processName}`);
-        } else if (Trace.isOfType(Process.ExitedEvent, event)) {
-          console.log(`[${message.meta.pid}] Process exited: ${event.data.outcome}`);
-        }
-      }
-    },
-  });