@dxos/functions 0.8.4-main.84f28bd → 0.8.4-main.b97322e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.84f28bd",
+  "version": "0.8.4-main.b97322e",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -47,41 +47,43 @@
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.88.0",
+    "@effect/platform": "0.89.0",
     "@preact/signals-core": "^1.9.0",
     "cron": "^3.1.6",
     "cron-schedule": "^5.0.4",
-    "effect": "3.16.13",
+    "effect": "3.17.0",
     "esbuild-wasm": "^0.16.14",
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
     "i18next": "^24.2.1",
     "iso-did": "^1.6.0",
     "ws": "^8.14.2",
-    "@dxos/ai": "0.8.4-main.84f28bd",
-    "@dxos/client": "0.8.4-main.84f28bd",
-    "@dxos/async": "0.8.4-main.84f28bd",
-    "@dxos/context": "0.8.4-main.84f28bd",
-    "@dxos/crypto": "0.8.4-main.84f28bd",
-    "@dxos/echo": "0.8.4-main.84f28bd",
-    "@dxos/echo-db": "0.8.4-main.84f28bd",
-    "@dxos/echo-protocol": "0.8.4-main.84f28bd",
-    "@dxos/echo-schema": "0.8.4-main.84f28bd",
-    "@dxos/edge-client": "0.8.4-main.84f28bd",
-    "@dxos/effect": "0.8.4-main.84f28bd",
-    "@dxos/invariant": "0.8.4-main.84f28bd",
-    "@dxos/keys": "0.8.4-main.84f28bd",
-    "@dxos/live-object": "0.8.4-main.84f28bd",
-    "@dxos/log": "0.8.4-main.84f28bd",
-    "@dxos/node-std": "0.8.4-main.84f28bd",
-    "@dxos/protocols": "0.8.4-main.84f28bd",
-    "@dxos/schema": "0.8.4-main.84f28bd",
-    "@dxos/util": "0.8.4-main.84f28bd"
+    "@dxos/ai": "0.8.4-main.b97322e",
+    "@dxos/async": "0.8.4-main.b97322e",
+    "@dxos/client": "0.8.4-main.b97322e",
+    "@dxos/crypto": "0.8.4-main.b97322e",
+    "@dxos/context": "0.8.4-main.b97322e",
+    "@dxos/echo-db": "0.8.4-main.b97322e",
+    "@dxos/echo": "0.8.4-main.b97322e",
+    "@dxos/echo-pipeline": "0.8.4-main.b97322e",
+    "@dxos/echo-protocol": "0.8.4-main.b97322e",
+    "@dxos/echo-schema": "0.8.4-main.b97322e",
+    "@dxos/effect": "0.8.4-main.b97322e",
+    "@dxos/edge-client": "0.8.4-main.b97322e",
+    "@dxos/errors": "0.8.4-main.b97322e",
+    "@dxos/invariant": "0.8.4-main.b97322e",
+    "@dxos/keys": "0.8.4-main.b97322e",
+    "@dxos/live-object": "0.8.4-main.b97322e",
+    "@dxos/log": "0.8.4-main.b97322e",
+    "@dxos/node-std": "0.8.4-main.b97322e",
+    "@dxos/protocols": "0.8.4-main.b97322e",
+    "@dxos/schema": "0.8.4-main.b97322e",
+    "@dxos/util": "0.8.4-main.b97322e"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.4-main.84f28bd"
+    "@dxos/agent": "0.8.4-main.b97322e"
   },
   "publishConfig": {
     "access": "public"

package/src/edge/functions.ts

@@ -8,7 +8,7 @@ import { type Client } from '@dxos/client';
 import { createEdgeIdentity } from '@dxos/client/edge';
 import { EdgeHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
-import type { PublicKey } from '@dxos/keys';
+import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type UploadFunctionResponseBody } from '@dxos/protocols';
 

package/src/errors.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BaseError } from '@dxos/errors';
+
+export class ServiceNotAvailableError extends BaseError.extend('SERVICE_NOT_AVAILABLE') {
+  constructor(serviceName: string) {
+    super(`Service not available: ${serviceName}`);
+  }
+}
+
+export class FunctionError extends BaseError.extend('FUNCTION_ERROR') {}

package/src/handler.ts

@@ -40,19 +40,19 @@ export type FunctionHandler<TData = {}, TOutput = any> = (params: {
  */
 export interface FunctionContext {
   /**
-   * Resolves a service available to the function.
-   * @throws if the service is not available.
+   * Space from which the function was invoked.
    */
-  getService: <T extends Context.Tag<any, any>>(tag: T) => Context.Tag.Service<T>;
+  space: SpaceAPI | undefined;
 
-  getSpace: (spaceId: SpaceId) => Promise<SpaceAPI>;
+  ai: AiServiceClient;
 
   /**
-   * Space from which the function was invoked.
+   * Resolves a service available to the function.
+   * @throws if the service is not available.
    */
-  space: SpaceAPI | undefined;
+  getService: <T extends Context.Tag<any, any>>(tag: T) => Context.Tag.Service<T>;
 
-  ai: AiServiceClient;
+  getSpace: (spaceId: SpaceId) => Promise<SpaceAPI>;
 }
 
 export interface FunctionContextAi {
@@ -76,10 +76,9 @@ export interface QueuesAPI {
  */
 export interface SpaceAPI {
   get id(): SpaceId;
-
   get db(): EchoDatabase;
 
-  // TODO(dmaretskyi): Align with echo api --- queues.get(id).append(items);
+  // TODO(dmaretskyi): Align with echo api: queues.get(id).append(items);
   get queues(): QueuesAPI;
 }
 
@@ -89,6 +88,7 @@ const __assertFunctionSpaceIsCompatibleWithTheClientSpace = () => {
 };
 
 export type FunctionDefinition<T = {}, O = any> = {
+  name: string;
   description?: string;
   inputSchema: Schema.Schema<T, any>;
   outputSchema?: Schema.Schema<O, any>;
@@ -96,18 +96,25 @@ export type FunctionDefinition<T = {}, O = any> = {
 };
 
 // TODO(dmaretskyi): Bind input type to function handler.
-export const defineFunction = <T, O>(params: FunctionDefinition<T, O>): FunctionDefinition<T, O> => {
-  if (!Schema.isSchema(params.inputSchema)) {
+export const defineFunction = <T, O>({
+  name,
+  description,
+  inputSchema,
+  outputSchema = Schema.Any,
+  handler,
+}: FunctionDefinition<T, O>): FunctionDefinition<T, O> => {
+  if (!Schema.isSchema(inputSchema)) {
     throw new Error('Input schema must be a valid schema');
   }
-  if (typeof params.handler !== 'function') {
+  if (typeof handler !== 'function') {
     throw new Error('Handler must be a function');
   }
 
   return {
-    description: params.description,
-    inputSchema: params.inputSchema,
-    outputSchema: params.outputSchema ?? Schema.Any,
-    handler: params.handler,
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    handler,
   };
 };

package/src/index.ts

@@ -9,5 +9,6 @@ export * from './types';
 export * from './url';
 export * from './services';
 export * from './executor';
+export * from './errors';
 
 // Blow up cache

package/src/services/credentials.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context } from 'effect';
+import { Context, Effect } from 'effect';
 
 type CredentialQuery = {
   service?: string;
@@ -31,7 +31,13 @@ export class CredentialsService extends Context.Tag('CredentialsService')<
      */
     getCredential: (query: CredentialQuery) => Promise<ServiceCredential>;
   }
->() {}
+>() {
+  static getCredential = (query: CredentialQuery): Effect.Effect<ServiceCredential, never, CredentialsService> =>
+    Effect.gen(function* () {
+      const credentials = yield* CredentialsService;
+      return yield* Effect.promise(() => credentials.getCredential(query));
+    });
+}
 
 export class ConfiguredCredentialsService implements Context.Tag.Service<CredentialsService> {
   constructor(private readonly credentials: ServiceCredential[] = []) {}

package/src/services/database.ts

@@ -4,8 +4,8 @@
 
 import { Context, Effect, Layer } from 'effect';
 
-import type { Obj, Ref, Relation } from '@dxos/echo';
-import type { EchoDatabase } from '@dxos/echo-db';
+import type { Filter, Live, Obj, Query, Ref, Relation } from '@dxos/echo';
+import type { EchoDatabase, OneShotQueryResult, QueryResult } from '@dxos/echo-db';
 import type { DXN } from '@dxos/keys';
 
 export class DatabaseService extends Context.Tag('DatabaseService')<
@@ -41,10 +41,30 @@ export class DatabaseService extends Context.Tag('DatabaseService')<
     },
   );
 
-  static loadRef: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, Error, never> = Effect.fn(function* (ref) {
-    return yield* Effect.tryPromise({
-      try: () => ref.load(),
-      catch: (error) => error as Error,
-    });
+  static loadRef: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, never, never> = Effect.fn(function* (ref) {
+    return yield* Effect.promise(() => ref.load());
   });
+
+  /**
+   * Creates a `QueryResult` object that can be subscribed to.
+   */
+  static query: {
+    <Q extends Query.Any>(query: Q): Effect.Effect<QueryResult<Live<Query.Type<Q>>>, never, DatabaseService>;
+    <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult<Live<Filter.Type<F>>>, never, DatabaseService>;
+  } = (queryOrFilter: Query.Any | Filter.Any) =>
+    DatabaseService.pipe(
+      Effect.map(({ db }) => db.query(queryOrFilter as any)),
+      Effect.withSpan('DatabaseService.query'),
+    );
+
+  /**
+   * Executes the query once and returns the results.
+   */
+  static runQuery: {
+    <Q extends Query.Any>(query: Q): Effect.Effect<OneShotQueryResult<Live<Query.Type<Q>>>, never, DatabaseService>;
+    <F extends Filter.Any>(filter: F): Effect.Effect<OneShotQueryResult<Live<Filter.Type<F>>>, never, DatabaseService>;
+  } = (queryOrFilter: Query.Any | Filter.Any) =>
+    DatabaseService.query(queryOrFilter as any).pipe(
+      Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())),
+    );
 }

package/src/services/index.ts

@@ -2,7 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './ai';
 export * from './database';
 export * from './queues';
 export * from './service-container';
@@ -10,4 +9,3 @@ export * from './credentials';
 export * from './tracing';
 export * from './event-logger';
 export * from './function-call-service';
-export * from './tool-resolver';

package/src/services/queues.ts

@@ -6,6 +6,9 @@ import { Context, Layer } from 'effect';
 
 import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
 
+/**
+ * Gives access to all queues.
+ */
 export class QueueService extends Context.Tag('QueueService')<
   QueueService,
   {
@@ -16,8 +19,8 @@ export class QueueService extends Context.Tag('QueueService')<
 
     /**
      * The queue that is used to store the context of the current research.
+     * @deprecated Use `ContextQueueService` instead.
      */
-    // TODO(dmaretskyi): Is this really part of the queue service?
     readonly contextQueue: Queue | undefined;
   }
 >() {
@@ -33,10 +36,20 @@ export class QueueService extends Context.Tag('QueueService')<
     contextQueue: undefined,
   });
 
-  static make = (queues: QueueFactory, contextQueue: Queue | undefined): Context.Tag.Service<QueueService> => {
+  static make = (queues: QueueFactory, contextQueue?: Queue): Context.Tag.Service<QueueService> => {
     return {
       queues,
       contextQueue,
     };
   };
 }
+
+/**
+ * Gives access to a specific queue passed as a context.
+ */
+export class ContextQueueService extends Context.Tag('ContextQueueService')<
+  ContextQueueService,
+  {
+    readonly contextQueue: Queue;
+  }
+>() {}

package/src/services/service-container.ts

@@ -2,68 +2,65 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Layer, type Context } from 'effect';
+import { type Context, Layer } from 'effect';
+
+import { AiService } from '@dxos/ai';
+import { entries } from '@dxos/util';
 
-import { AiService } from './ai';
 import { ConfiguredCredentialsService, CredentialsService } from './credentials';
 import { DatabaseService } from './database';
 import { EventLogger } from './event-logger';
 import { FunctionCallService } from './function-call-service';
 import { QueueService } from './queues';
-import { ToolResolverService } from './tool-resolver';
 import { TracingService } from './tracing';
 
+// TODO(dmaretskyi): Refactor this module to only rely on tags and not the human-assigned names.
+
 /**
- * List of all service tags and their names.
+ * List of all services.
  */
-export interface ServiceTagRecord {
-  ai: AiService;
-  credentials: CredentialsService;
-  database: DatabaseService;
-  eventLogger: EventLogger;
-  functionCallService: FunctionCallService;
-  tracing: TracingService;
-  queues: QueueService;
-  toolResolver: ToolResolverService;
-}
+const SERVICES = {
+  ai: AiService,
+  credentials: CredentialsService,
+  database: DatabaseService,
+  eventLogger: EventLogger,
+  functionCallService: FunctionCallService,
+  queues: QueueService,
+  tracing: TracingService,
+} as const satisfies Record<string, Context.TagClass<any, string, any>>;
+
+/**
+ * Mapping of service names to their tags.
+ */
+export type ServiceTagRecord = {
+  [K in keyof typeof SERVICES]: (typeof SERVICES)[K] extends { new (_: never): infer T } ? T : never;
+};
 
 /**
- * List of all services and their runtime types.
+ * Mapping of service names to their runtime types.
  */
 export type ServiceRecord = {
   [K in keyof ServiceTagRecord]: Context.Tag.Service<ServiceTagRecord[K]>;
 };
 
 /**
- * Union of all services.
+ * Union of all services tags.
  */
 export type Services = ServiceTagRecord[keyof ServiceTagRecord];
 
-const SERVICE_MAPPING: Record<string, keyof ServiceRecord> = {
-  [AiService.key]: 'ai',
-  [CredentialsService.key]: 'credentials',
-  [DatabaseService.key]: 'database',
-  [EventLogger.key]: 'eventLogger',
-  [FunctionCallService.key]: 'functionCallService',
-  [QueueService.key]: 'queues',
-  [TracingService.key]: 'tracing',
-  [ToolResolverService.key]: 'toolResolver',
-};
+const SERVICE_MAPPING: Record<string, keyof ServiceRecord> = Object.fromEntries(
+  entries(SERVICES).map(([name, tag]) => [tag.key, name]),
+);
 
-export const SERVICE_TAGS: Context.Tag<any, any>[] = [
-  AiService,
-  CredentialsService,
-  DatabaseService,
-  EventLogger,
-  FunctionCallService,
-  TracingService,
-  QueueService,
-];
+export const SERVICE_TAGS: Context.Tag<any, any>[] = Object.values(SERVICES);
 
 const DEFAULT_SERVICES: Partial<ServiceRecord> = {
   tracing: TracingService.noop,
 };
 
+/**
+ * @deprecated
+ */
 export class ServiceContainer {
   private _services: Partial<ServiceRecord> = { ...DEFAULT_SERVICES };
 
@@ -94,7 +91,10 @@ export class ServiceContainer {
   // TODO(dmaretskyi): `getService` is designed to error at runtime if the service is not available, but layer forces us to provide all services and makes stubs for the ones that are not available.
   createLayer(): Layer.Layer<Services> {
     const ai = this._services.ai != null ? Layer.succeed(AiService, this._services.ai) : AiService.notAvailable;
-    const credentials = Layer.succeed(CredentialsService, new ConfiguredCredentialsService());
+    const credentials = Layer.succeed(
+      CredentialsService,
+      this._services.credentials ?? new ConfiguredCredentialsService(),
+    );
     const database =
       this._services.database != null
         ? Layer.succeed(DatabaseService, this._services.database)
@@ -107,21 +107,7 @@ export class ServiceContainer {
       FunctionCallService,
       this._services.functionCallService ?? FunctionCallService.mock(),
     );
-    const toolResolver = Layer.succeed(
-      ToolResolverService,
-      this._services.toolResolver ?? ToolResolverService.notAvailable,
-    );
 
-    return Layer.mergeAll(
-      //
-      ai,
-      credentials,
-      database,
-      queues,
-      tracing,
-      eventLogger,
-      functionCallService,
-      toolResolver,
-    );
+    return Layer.mergeAll(ai, credentials, database, queues, tracing, eventLogger, functionCallService);
   }
 }

package/src/services/service-registry.test.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import { Context, Effect, Layer, Option } from 'effect';
+
+import { ServiceRegistry } from './service-registry';
+
+class MyTag extends Context.Tag('MyTag')<MyTag, { value: string }>() {}
+
+const mockRegistry = Layer.succeed(ServiceRegistry, {
+  resolve: (tag) => ((tag as any) === MyTag ? Option.some({ value: 'test' } as any) : Option.none()),
+});
+
+describe('ServiceRegistry', () => {
+  it.effect(
+    'provide',
+    Effect.fn(function* ({ expect }) {
+      const body = Effect.gen(function* () {
+        const { value } = yield* MyTag;
+        expect(value).toEqual('test');
+      });
+
+      const eff = body.pipe(ServiceRegistry.provide(MyTag));
+      yield* eff;
+    }, Effect.provide(mockRegistry)),
+  );
+
+  it.effect(
+    'provide or die',
+    Effect.fn(function* ({ expect }) {
+      const body = Effect.gen(function* () {
+        const { value } = yield* MyTag;
+        expect(value).toEqual('test');
+      });
+
+      const eff = body.pipe(ServiceRegistry.provideOrDie(MyTag));
+      yield* eff;
+    }, Effect.provide(mockRegistry)),
+  );
+});

package/src/services/service-registry.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context, Effect, flow, type Option } from 'effect';
+
+import { ServiceNotAvailableError } from '../errors';
+
+export namespace ServiceRegistry {
+  export interface Service {
+    resolve: <T extends Context.Tag<any, any>>(tag: T) => Option.Option<Context.Tag.Service<T>>;
+  }
+}
+
+export class ServiceRegistry extends Context.Tag('ServiceRegistry')<ServiceRegistry, ServiceRegistry.Service>() {
+  /**
+   * Resolves the service from the registry.
+   * @param tag Service tag to resolve.
+   * @throws {@link ServiceNotAvailableError} if the service is not found.
+   * @returns Effect that resolve to the service.
+   */
+  static resolve: <T extends Context.Tag<any, any>>(
+    tag: T,
+  ) => Effect.Effect<T, ServiceNotAvailableError, ServiceRegistry> = (tag) =>
+    ServiceRegistry.pipe(
+      Effect.flatMap((_) => _.resolve(tag)),
+      Effect.mapError(() => new ServiceNotAvailableError(tag.key)),
+    );
+
+  static provide: {
+    <Tags extends [Context.Tag<any, any>, ...Context.Tag<any, any>[]]>(
+      ...tags: Tags
+    ): <A, E, R>(
+      effect: Effect.Effect<A, E, R>,
+    ) => Effect.Effect<
+      A,
+      E | ServiceNotAvailableError,
+      Exclude<R, { [K in keyof Tags]: Context.Tag.Identifier<Tags[K]> }[number]> | ServiceRegistry
+    >;
+  } = (...tags) => (flow as any)(...tags.map((tag) => Effect.provideServiceEffect(tag, ServiceRegistry.resolve(tag))));
+
+  static provideOrDie: {
+    <Tags extends [Context.Tag<any, any>, ...Context.Tag<any, any>[]]>(
+      ...tags: Tags
+    ): <A, E, R>(
+      effect: Effect.Effect<A, E, R>,
+    ) => Effect.Effect<
+      A,
+      E,
+      Exclude<R, { [K in keyof Tags]: Context.Tag.Identifier<Tags[K]> }[number]> | ServiceRegistry
+    >;
+  } = (...tags) =>
+    (flow as any)(
+      ...tags.map((tag) => Effect.provideServiceEffect(tag, ServiceRegistry.resolve(tag).pipe(Effect.orDie))),
+    );
+}

package/src/services/tracing.ts

@@ -2,10 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context } from 'effect';
+import { Context, Effect } from 'effect';
 
+import { AgentStatus } from '@dxos/ai';
+import { Obj } from '@dxos/echo';
 import type { AnyEchoObject } from '@dxos/echo-schema';
 
+/**
+ * Provides a way for compute primitives (functions, workflows, tools)
+ * to emit an execution trace as a series of structured ECHO objects.
+ */
 export class TracingService extends Context.Tag('TracingService')<
   TracingService,
   {
@@ -24,4 +30,13 @@ export class TracingService extends Context.Tag('TracingService')<
       console.log(event);
     },
   };
+
+  /**
+   * Emit the current human-readable execution status.
+   */
+  static emitStatus: (data: Obj.MakeProps<typeof AgentStatus>) => Effect.Effect<unknown, never, void> =
+    Effect.fnUntraced(function* (data) {
+      const tracing = yield* TracingService;
+      tracing.write(Obj.make(AgentStatus, data));
+    });
 }

package/src/testing/index.ts

@@ -3,3 +3,4 @@
 //
 
 export * from './services';
+export * from './layer';

package/src/testing/layer.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context, Effect, Layer } from 'effect';
+import type { Schema } from 'effect';
+
+import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import type { EchoHostIndexingConfig } from '@dxos/echo-pipeline';
+import { accuireReleaseResource } from '@dxos/effect';
+
+import { DatabaseService, QueueService } from '../services';
+
+const testBuilder = accuireReleaseResource(() => new EchoTestBuilder());
+
+export type TestDatabaseOptions = {
+  indexing?: Partial<EchoHostIndexingConfig>;
+  types?: Schema.Schema.AnyNoContext[];
+};
+
+export const TestDatabaseLayer = ({ indexing, types }: TestDatabaseOptions = {}) =>
+  Layer.scopedContext(
+    Effect.gen(function* () {
+      const builder = yield* testBuilder;
+      const { db, queues } = yield* Effect.promise(() => builder.createDatabase({ indexing, types }));
+      return Context.mergeAll(
+        Context.make(DatabaseService, DatabaseService.make(db)),
+        Context.make(QueueService, QueueService.make(queues, undefined)),
+      );
+    }),
+  );

package/src/testing/services.ts

@@ -4,7 +4,7 @@
 
 import { type Context } from 'effect';
 
-import { type AiServiceEdgeClientOptions, EdgeAiServiceClient, type AiServiceClient, ToolRegistry } from '@dxos/ai';
+import { AiService, type AiServiceClient, type AiServiceEdgeClientOptions, EdgeAiServiceClient } from '@dxos/ai';
 import { AI_SERVICE_ENDPOINT, createTestAiServiceClient } from '@dxos/ai/testing';
 import type { Space } from '@dxos/client/echo';
 import type { EchoDatabase, QueueFactory } from '@dxos/echo-db';
@@ -12,7 +12,6 @@ import { assertArgument } from '@dxos/invariant';
 
 import { consoleLogger, noopLogger } from './logger';
 import {
-  AiService,
   ConfiguredCredentialsService,
   type CredentialsService,
   DatabaseService,
@@ -20,7 +19,6 @@ import {
   QueueService,
   ServiceContainer,
   type ServiceCredential,
-  ToolResolverService,
   type TracingService,
 } from '../services';
 
@@ -95,8 +93,6 @@ export type TestServiceOptions = {
   tracing?: {
     service?: Context.Tag.Service<TracingService>;
   };
-
-  toolResolver?: Context.Tag.Service<ToolResolverService>;
 };
 
 export const createTestServices = ({
@@ -107,7 +103,6 @@ export const createTestServices = ({
   queues,
   space,
   tracing,
-  toolResolver,
 }: TestServiceOptions = {}): ServiceContainer => {
   assertArgument(!(!!space && (!!db || !!queues)), 'space can be provided only if db and queues are not');
 
@@ -115,10 +110,9 @@ export const createTestServices = ({
     ai: createAiService(ai),
     credentials: createCredentialsService(credentials),
     database: space || db ? DatabaseService.make(space?.db || db!) : undefined,
-    eventLogger: logging?.logger ?? logging?.enabled ? consoleLogger : noopLogger,
+    eventLogger: (logging?.logger ?? logging?.enabled) ? consoleLogger : noopLogger,
     queues: space || queues ? QueueService.make(space?.queues || queues!, undefined) : undefined,
     tracing: tracing?.service,
-    toolResolver: toolResolver ?? ToolResolverService.make(new ToolRegistry([])),
   });
 };