@dxos/functions 0.8.3 → 0.8.4-main.f9ba587

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.3",
+  "version": "0.8.4-main.f9ba587",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -9,11 +9,6 @@
   "sideEffects": true,
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
-    },
     "./bundler": {
       "types": "./dist/types/src/bundler/index.d.ts",
       "browser": "./dist/lib/browser/bundler/index.mjs",
@@ -24,6 +19,11 @@
       "browser": "./dist/lib/browser/edge/index.mjs",
       "node": "./dist/lib/node-esm/edge/index.mjs"
     },
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "browser": "./dist/lib/browser/index.mjs",
+      "node": "./dist/lib/node-esm/index.mjs"
+    },
     "./testing": {
       "types": "./dist/types/src/testing/index.d.ts",
       "browser": "./dist/lib/browser/testing/index.mjs",
@@ -47,38 +47,41 @@
     "src"
   ],
   "dependencies": {
+    "@effect/platform": "0.88.0",
     "@preact/signals-core": "^1.9.0",
     "cron": "^3.1.6",
     "cron-schedule": "^5.0.4",
-    "effect": "3.14.21",
+    "effect": "3.16.13",
     "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.3",
-    "@dxos/client": "0.8.3",
-    "@dxos/async": "0.8.3",
-    "@dxos/crypto": "0.8.3",
-    "@dxos/echo": "0.8.3",
-    "@dxos/context": "0.8.3",
-    "@dxos/echo-protocol": "0.8.3",
-    "@dxos/echo-db": "0.8.3",
-    "@dxos/echo-schema": "0.8.3",
-    "@dxos/edge-client": "0.8.3",
-    "@dxos/invariant": "0.8.3",
-    "@dxos/keys": "0.8.3",
-    "@dxos/live-object": "0.8.3",
-    "@dxos/log": "0.8.3",
-    "@dxos/node-std": "0.8.3",
-    "@dxos/protocols": "0.8.3",
-    "@dxos/schema": "0.8.3",
-    "@dxos/util": "0.8.3"
+    "@dxos/ai": "0.8.4-main.f9ba587",
+    "@dxos/async": "0.8.4-main.f9ba587",
+    "@dxos/client": "0.8.4-main.f9ba587",
+    "@dxos/context": "0.8.4-main.f9ba587",
+    "@dxos/crypto": "0.8.4-main.f9ba587",
+    "@dxos/echo": "0.8.4-main.f9ba587",
+    "@dxos/echo-db": "0.8.4-main.f9ba587",
+    "@dxos/echo-protocol": "0.8.4-main.f9ba587",
+    "@dxos/echo-schema": "0.8.4-main.f9ba587",
+    "@dxos/edge-client": "0.8.4-main.f9ba587",
+    "@dxos/effect": "0.8.4-main.f9ba587",
+    "@dxos/keys": "0.8.4-main.f9ba587",
+    "@dxos/invariant": "0.8.4-main.f9ba587",
+    "@dxos/live-object": "0.8.4-main.f9ba587",
+    "@dxos/log": "0.8.4-main.f9ba587",
+    "@dxos/node-std": "0.8.4-main.f9ba587",
+    "@dxos/protocols": "0.8.4-main.f9ba587",
+    "@dxos/schema": "0.8.4-main.f9ba587",
+    "@dxos/util": "0.8.4-main.f9ba587"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.3"
+    "@dxos/agent": "0.8.4-main.f9ba587"
   },
   "publishConfig": {
     "access": "public"

package/src/bundler/bundler.test.ts

@@ -37,7 +37,7 @@ describe('Bundler', () => {
     expect(result.error).to.not.exist;
   });
 
-  // TODO(dmaretskyi): Flaky on CI: https://cloud.nx.app/runs/Hjcifa8Ccq/task/plugin-script%3Atest
+  // TODO(dmaretskyi): Flaky on CI.
   test.skip('HTTPS Import', async () => {
     const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
     const result = await bundler.bundle({

package/src/bundler/bundler.ts

@@ -2,10 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type BuildOptions } from 'esbuild';
-import { build, initialize, type BuildResult, type Plugin } from 'esbuild-wasm';
+import { FetchHttpClient, HttpClient } from '@effect/platform';
+import { Duration, Effect, pipe, Schedule } from 'effect';
+import { type BuildOptions, type Loader, build, initialize, type BuildResult, type Plugin } from 'esbuild-wasm';
 
 import { subtleCrypto } from '@dxos/crypto';
+import { runAndForwardErrors } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
@@ -242,6 +244,9 @@ const analyzeSourceFileImports = (code: string): ParsedImport[] => {
   });
 };
 
+const MAX_RETRIES = 5;
+const INITIAL_DELAY = 1_000;
+
 const httpPlugin: Plugin = {
   name: 'http',
   setup: (build) => {
@@ -263,8 +268,25 @@ const httpPlugin: Plugin = {
     // When a URL is loaded, we want to actually download the content from the internet.
     // This has just enough logic to be able to handle the example import from unpkg.com but in reality this would probably need to be more complex.
     build.onLoad({ filter: /.*/, namespace: 'http-url' }, async (args) => {
-      const response = await fetch(args.path);
-      return { contents: await response.text(), loader: 'jsx' };
+      return Effect.gen(function* () {
+        const response = yield* HttpClient.get(args.path);
+        if (response.status !== 200) {
+          throw new Error(`failed to fetch: ${response.status}`);
+        }
+
+        const text = yield* response.text;
+        return { contents: text, loader: 'jsx' as Loader };
+      }).pipe(
+        Effect.retry(
+          pipe(
+            Schedule.exponential(Duration.millis(INITIAL_DELAY)),
+            Schedule.jittered,
+            Schedule.intersect(Schedule.recurs(MAX_RETRIES - 1)),
+          ),
+        ),
+        Effect.provide(FetchHttpClient.layer),
+        runAndForwardErrors,
+      );
     });
   },
 };

package/src/executor/executor.ts

@@ -5,9 +5,10 @@
 import { Effect, Schema } from 'effect';
 
 import type { SpaceId } from '@dxos/client/echo';
+import { runAndForwardErrors } from '@dxos/effect';
 
 import type { FunctionContext, FunctionDefinition } from '../handler';
-import type { ServiceContainer } from '../services';
+import type { ServiceContainer, Services } from '../services';
 
 export class FunctionExecutor {
   constructor(private readonly _services: ServiceContainer) {}
@@ -32,16 +33,22 @@ export class FunctionExecutor {
       },
     };
 
-    const result = await fnDef.handler({ context, data: input });
-
-    // Assert output matches schema
-    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(result);
+    const result = fnDef.handler({ context, data: input });
 
+    let data: unknown;
     if (Effect.isEffect(result)) {
-      return Effect.runPromise(result as any);
+      data = await (result as Effect.Effect<unknown, unknown, Services>).pipe(
+        Effect.provide(this._services.createLayer()),
+        runAndForwardErrors,
+      );
+    } else {
+      data = await result;
     }
 
-    return result as any;
+    // Assert output matches schema
+    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
+    (assertOutput as any)(data);
+
+    return data as any;
   }
 }

package/src/handler.ts

@@ -6,11 +6,13 @@ import { Schema, type Context, type Effect } from 'effect';
 
 import { type AiServiceClient } from '@dxos/ai';
 // import { type Space } from '@dxos/client/echo';
-import type { CoreDatabase, EchoDatabase } from '@dxos/echo-db';
+import type { EchoDatabase } from '@dxos/echo-db';
 import { type HasId } from '@dxos/echo-schema';
 import { type SpaceId, type DXN } from '@dxos/keys';
 import { type QueryResult } from '@dxos/protocols';
 
+import type { Services } from './services';
+
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
 // https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
@@ -31,7 +33,7 @@ export type FunctionHandler<TData = {}, TOutput = any> = (params: {
    * This will be the payload from the trigger or other data passed into the function in a workflow.
    */
   data: TData;
-}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any>;
+}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, Services>;
 
 /**
  * Function context.
@@ -74,11 +76,9 @@ export interface QueuesAPI {
  */
 export interface SpaceAPI {
   get id(): SpaceId;
-  /**
-   * @deprecated
-   */
-  get crud(): CoreDatabase;
+
   get db(): EchoDatabase;
+
   // TODO(dmaretskyi): Align with echo api --- queues.get(id).append(items);
   get queues(): QueuesAPI;
 }

package/src/services/credentials.ts

@@ -10,7 +10,7 @@ type CredentialQuery = {
 
 // TODO(dmaretskyi): Unify with other apis.
 // packages/sdk/schema/src/common/access-token.ts
-type ServiceCredential = {
+export type ServiceCredential = {
   service: string;
 
   // TODO(dmaretskyi): Build out.

package/src/services/database.ts

@@ -2,9 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Layer } from 'effect';
+import { Context, Effect, Layer } from 'effect';
 
+import type { Obj, Ref, Relation } from '@dxos/echo';
 import type { EchoDatabase } from '@dxos/echo-db';
+import type { DXN } from '@dxos/keys';
 
 export class DatabaseService extends Context.Tag('DatabaseService')<
   DatabaseService,
@@ -25,4 +27,24 @@ export class DatabaseService extends Context.Tag('DatabaseService')<
       },
     };
   };
+
+  static resolve: (dxn: DXN) => Effect.Effect<Obj.Any | Relation.Any, Error, DatabaseService> = Effect.fn(
+    function* (dxn) {
+      const { db } = yield* DatabaseService;
+      return yield* Effect.tryPromise({
+        try: () =>
+          db.graph.createRefResolver({ context: { space: db.spaceId } }).resolve(dxn) as Promise<
+            Obj.Any | Relation.Any
+          >,
+        catch: (error) => error as Error,
+      });
+    },
+  );
+
+  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,
+    });
+  });
 }

package/src/services/index.ts

@@ -10,3 +10,4 @@ export * from './credentials';
 export * from './tracing';
 export * from './event-logger';
 export * from './function-call-service';
+export * from './tool-resolver';

package/src/services/queues.ts

@@ -4,7 +4,7 @@
 
 import { Context, Layer } from 'effect';
 
-import type { Queue, QueueFactory } from '@dxos/echo-db';
+import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
 
 export class QueueService extends Context.Tag('QueueService')<
   QueueService,
@@ -12,7 +12,7 @@ export class QueueService extends Context.Tag('QueueService')<
     /**
      * API to access the queues.
      */
-    readonly queues: QueueFactory;
+    readonly queues: QueueAPI;
 
     /**
      * The queue that is used to store the context of the current research.
@@ -22,8 +22,13 @@ export class QueueService extends Context.Tag('QueueService')<
   }
 >() {
   static notAvailable = Layer.succeed(QueueService, {
-    get queues(): QueueFactory {
-      throw new Error('Queues not available');
+    queues: {
+      get(dxn) {
+        throw new Error('Queues not available');
+      },
+      create() {
+        throw new Error('Queues not available');
+      },
     },
     contextQueue: undefined,
   });

package/src/services/service-container.ts

@@ -10,6 +10,7 @@ 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';
 
 /**
@@ -23,6 +24,7 @@ export interface ServiceTagRecord {
   functionCallService: FunctionCallService;
   tracing: TracingService;
   queues: QueueService;
+  toolResolver: ToolResolverService;
 }
 
 /**
@@ -45,6 +47,7 @@ const SERVICE_MAPPING: Record<string, keyof ServiceRecord> = {
   [FunctionCallService.key]: 'functionCallService',
   [QueueService.key]: 'queues',
   [TracingService.key]: 'tracing',
+  [ToolResolverService.key]: 'toolResolver',
 };
 
 export const SERVICE_TAGS: Context.Tag<any, any>[] = [
@@ -74,13 +77,14 @@ export class ServiceContainer {
     return this;
   }
 
-  getService<T extends Context.Tag<any, any>>(tag: T): Context.Tag.Service<T> {
+  getService<Id, T>(tag: Context.Tag<Id, T>): T {
     const serviceKey = SERVICE_MAPPING[tag.key];
     const service = serviceKey != null ? this._services[serviceKey] : undefined;
     if (!service) {
       throw new Error(`Service not available: ${tag.key}`);
     }
-    return service as Context.Tag.Service<T>;
+
+    return service as T;
   }
 
   clone(): ServiceContainer {
@@ -103,7 +107,21 @@ 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);
+    return Layer.mergeAll(
+      //
+      ai,
+      credentials,
+      database,
+      queues,
+      tracing,
+      eventLogger,
+      functionCallService,
+      toolResolver,
+    );
   }
 }

package/src/services/tool-resolver.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context } from 'effect';
+
+import { type ToolResolver } from '@dxos/ai';
+
+export class ToolResolverService extends Context.Tag('ToolResolverService')<
+  ToolResolverService,
+  {
+    /**
+     * Tool resolver.
+     */
+    readonly toolResolver: ToolResolver;
+  }
+>() {
+  static notAvailable: Context.Tag.Service<ToolResolverService> = {
+    toolResolver: {
+      resolve: async (id: string) => {
+        throw new Error('Tool resolver not available');
+      },
+    },
+  };
+
+  static make = (toolResolver: ToolResolver): Context.Tag.Service<ToolResolverService> => {
+    return {
+      toolResolver,
+    };
+  };
+}

package/src/testing/services.ts

@@ -4,29 +4,171 @@
 
 import { type Context } from 'effect';
 
-import type { AiServiceClient } from '@dxos/ai';
-import type { QueueFactory } from '@dxos/echo-db';
+import { type AiServiceEdgeClientOptions, EdgeAiServiceClient, type AiServiceClient, ToolRegistry } 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';
+import { assertArgument } from '@dxos/invariant';
 
 import { consoleLogger, noopLogger } from './logger';
-import { AiService, QueueService, ServiceContainer } from '../services';
-import type { EventLogger } from '../services/event-logger';
+import {
+  AiService,
+  ConfiguredCredentialsService,
+  type CredentialsService,
+  DatabaseService,
+  type EventLogger,
+  QueueService,
+  ServiceContainer,
+  type ServiceCredential,
+  ToolResolverService,
+  type TracingService,
+} from '../services';
+
+// TODO(burdon): Factor out.
+export type OneOf<T> = {
+  [K in keyof T]: { [P in K]: T[P] } & { [P in Exclude<keyof T, K>]?: never };
+}[keyof T];
+
+export type AiServiceProvider = 'dev' | 'edge' | 'ollama' | 'lmstudio';
 
 export type TestServiceOptions = {
-  ai?: AiServiceClient;
-  queueFactory?: QueueFactory;
-  enableLogging?: boolean;
-  logger?: Context.Tag.Service<EventLogger>;
+  /**
+   * AI service configuration.
+   */
+  ai?: OneOf<{
+    /**
+     * Custom AI service client.
+     */
+    client?: AiServiceClient;
+
+    /**
+     * Edge AI service at specified endpoint.
+     */
+    endpoint?: AiServiceEdgeClientOptions['endpoint'];
+
+    /**
+     * Predefined AI service configuration.
+     */
+    // TODO(burdon): 'dev' and 'edge' are redundant with providing an endpoint.
+    provider?: AiServiceProvider;
+  }>;
+
+  /**
+   * Credentials service configuration.
+   */
+  credentials?: OneOf<{
+    /**
+     * Predefined credentials list.
+     */
+    services?: ServiceCredential[];
+
+    /**
+     * Custom credentials service.
+     */
+    service?: Context.Tag.Service<CredentialsService>;
+  }>;
+
+  /**
+   * Database configuration.
+   */
+  db?: EchoDatabase;
+
+  /**
+   * Gets database and queue services from the space.
+   * Exclusive with: `db`, `queues`
+   */
+  space?: Space;
+
+  /**
+   * Logging configuration.
+   */
+  logging?: {
+    enabled?: boolean;
+    logger?: Context.Tag.Service<EventLogger>;
+  };
+
+  /**
+   * Queue service configuration.
+   */
+  queues?: QueueFactory;
+
+  tracing?: {
+    service?: Context.Tag.Service<TracingService>;
+  };
+
+  toolResolver?: Context.Tag.Service<ToolResolverService>;
 };
 
 export const createTestServices = ({
   ai,
-  queueFactory,
-  enableLogging = false,
-  logger = enableLogging ? consoleLogger : noopLogger,
+  credentials,
+  db,
+  logging,
+  queues,
+  space,
+  tracing,
+  toolResolver,
 }: TestServiceOptions = {}): ServiceContainer => {
+  assertArgument(!(!!space && (!!db || !!queues)), 'space can be provided only if db and queues are not');
+
   return new ServiceContainer().setServices({
-    ai: ai != null ? AiService.make(ai) : undefined,
-    eventLogger: logger,
-    queues: queueFactory != null ? QueueService.make(queueFactory, undefined) : undefined,
+    ai: createAiService(ai),
+    credentials: createCredentialsService(credentials),
+    database: space || db ? DatabaseService.make(space?.db || db!) : undefined,
+    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([])),
   });
 };
+
+// TODO(burdon): Enable model configuration.
+const createAiService = (ai: TestServiceOptions['ai']): Context.Tag.Service<AiService> | undefined => {
+  if (ai?.client != null) {
+    return AiService.make(ai.client);
+  }
+
+  if (ai?.endpoint != null) {
+    return AiService.make(new EdgeAiServiceClient({ endpoint: ai.endpoint }));
+  }
+
+  switch (ai?.provider) {
+    case 'dev':
+      return AiService.make(
+        new EdgeAiServiceClient({
+          endpoint: AI_SERVICE_ENDPOINT.LOCAL,
+          defaultGenerationOptions: {
+            model: '@anthropic/claude-3-5-sonnet-20241022',
+          },
+        }),
+      );
+
+    case 'edge':
+      return AiService.make(
+        new EdgeAiServiceClient({
+          endpoint: AI_SERVICE_ENDPOINT.REMOTE,
+          defaultGenerationOptions: {
+            model: '@anthropic/claude-3-5-sonnet-20241022',
+          },
+        }),
+      );
+
+    case 'ollama':
+      return AiService.make(createTestAiServiceClient());
+
+    case 'lmstudio':
+      throw new Error('LMStudio is not supported');
+  }
+};
+
+const createCredentialsService = (
+  credentials: TestServiceOptions['credentials'] | undefined,
+): Context.Tag.Service<CredentialsService> | undefined => {
+  if (credentials?.services) {
+    return new ConfiguredCredentialsService(credentials.services);
+  }
+
+  if (credentials?.service) {
+    return credentials.service;
+  }
+};

package/src/translations.ts

@@ -2,14 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Type } from '@dxos/echo';
+import { type Resource } from 'i18next';
 
 import { ScriptType } from './schema';
 
-export default [
+export const translations = [
   {
     'en-US': {
-      [Type.getTypename(ScriptType)]: {
+      [ScriptType.typename]: {
         'typename label': 'Script',
         'typename label_zero': 'Scripts',
         'typename label_one': 'Script',
@@ -17,4 +17,4 @@ export default [
       },
     },
   },
-];
+] as const satisfies Resource[];