@dxos/functions 0.8.3-main.672df60 → 0.8.3-staging.0fa589b

package/src/services/event-logger.ts

@@ -0,0 +1,87 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Context } from 'effect';
+
+import { invariant } from '@dxos/invariant';
+import { log, LogLevel } from '@dxos/log';
+
+export type ComputeEvent =
+  | {
+      type: 'begin-compute';
+      nodeId: string;
+      inputs: Record<string, any>;
+    }
+  | {
+      type: 'end-compute';
+      nodeId: string;
+      outputs: Record<string, any>;
+    }
+  | {
+      type: 'compute-input';
+      nodeId: string;
+      property: string;
+      value: any;
+    }
+  | {
+      type: 'compute-output';
+      nodeId: string;
+      property: string;
+      value: any;
+    }
+  | {
+      type: 'custom';
+      nodeId: string;
+      event: any;
+    };
+
+export class EventLogger extends Context.Tag('EventLogger')<
+  EventLogger,
+  { readonly log: (event: ComputeEvent) => void; readonly nodeId: string | undefined }
+>() {
+  static noop: Context.Tag.Service<EventLogger> = {
+    log: () => {},
+    nodeId: undefined,
+  };
+}
+
+export const logCustomEvent = (data: any) =>
+  Effect.gen(function* () {
+    const logger = yield* EventLogger;
+    if (!logger.nodeId) {
+      throw new Error('logCustomEvent must be called within a node compute function');
+    }
+    logger.log({
+      type: 'custom',
+      nodeId: logger.nodeId,
+      event: data,
+    });
+  });
+
+export const createDefectLogger = <A, E, R>(): ((self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>) =>
+  Effect.catchAll((error) =>
+    Effect.gen(function* () {
+      log.error('unhandled effect error', { error });
+      throw error;
+    }),
+  );
+
+export const createEventLogger = (level: LogLevel, message: string = 'event'): Context.Tag.Service<EventLogger> => {
+  const logFunction = (
+    {
+      [LogLevel.WARN]: log.warn,
+      [LogLevel.VERBOSE]: log.verbose,
+      [LogLevel.DEBUG]: log.debug,
+      [LogLevel.INFO]: log.info,
+      [LogLevel.ERROR]: log.error,
+    } as any
+  )[level];
+  invariant(logFunction);
+  return {
+    log: (event: ComputeEvent) => {
+      logFunction(message, event);
+    },
+    nodeId: undefined,
+  };
+};

package/src/services/function-call-service.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context } from 'effect';
+
+import type { SpaceId } from '@dxos/keys';
+
+/**
+ * Allows calling into other functions.
+ */
+export class FunctionCallService extends Context.Tag('FunctionCallService')<
+  FunctionCallService,
+  {
+    callFunction(deployedFunctionId: string, input: any, spaceId?: SpaceId): Promise<any>;
+  }
+>() {
+  static fromClient(baseUrl: string, spaceId: SpaceId): Context.Tag.Service<FunctionCallService> {
+    return {
+      callFunction: async (deployedFunctionId: string, input: any) => {
+        const url = getInvocationUrl(deployedFunctionId, baseUrl, { spaceId });
+        const result = await fetch(url, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(input),
+        });
+        if (result.status >= 300 || result.status < 200) {
+          throw new Error('Failed to invoke function', { cause: new Error(`HTTP error: ${await result.text()}`) });
+        }
+        return await result.json();
+      },
+    };
+  }
+
+  static mock = () => {
+    return {
+      callFunction: async (deployedFunctionId: string, input: any) => {
+        return input;
+      },
+    };
+  };
+}
+
+// TODO(dmaretskyi): Reconcile with `getInvocationUrl` in `@dxos/functions/edge`.
+const getInvocationUrl = (functionUrl: string, edgeUrl: string, options: InvocationOptions = {}) => {
+  const baseUrl = new URL('functions/', edgeUrl);
+
+  // Leading slashes cause the URL to be treated as an absolute path.
+  const relativeUrl = functionUrl.replace(/^\//, '');
+  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
+  options.spaceId && url.searchParams.set('spaceId', options.spaceId);
+  options.subjectId && url.searchParams.set('subjectId', options.subjectId);
+  url.protocol = isSecure(url.protocol) ? 'https' : 'http';
+  return url.toString();
+};
+
+const isSecure = (protocol: string) => {
+  return protocol === 'https:' || protocol === 'wss:';
+};
+
+type InvocationOptions = {
+  spaceId?: SpaceId;
+  subjectId?: string;
+};

package/src/services/index.ts

@@ -8,3 +8,5 @@ export * from './queues';
 export * from './service-container';
 export * from './credentials';
 export * from './tracing';
+export * from './event-logger';
+export * from './function-call-service';

package/src/services/queues.ts

@@ -2,15 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context } from 'effect';
+import { Context, Layer } from 'effect';
 
 import type { Queue, QueueFactory } from '@dxos/echo-db';
 
-export class QueuesService extends Context.Tag('QueuesService')<
-  QueuesService,
+export class QueueService extends Context.Tag('QueueService')<
+  QueueService,
   {
-    readonly contextQueue: Queue | undefined;
-
+    /**
+     * API to access the queues.
+     */
     readonly queues: QueueFactory;
+
+    /**
+     * The queue that is used to store the context of the current research.
+     */
+    // TODO(dmaretskyi): Is this really part of the queue service?
+    readonly contextQueue: Queue | undefined;
   }
->() {}
+>() {
+  static notAvailable = Layer.succeed(QueueService, {
+    get queues(): QueueFactory {
+      throw new Error('Queues not available');
+    },
+    contextQueue: undefined,
+  });
+
+  static make = (queues: QueueFactory, contextQueue: Queue | undefined): Context.Tag.Service<QueueService> => {
+    return {
+      queues,
+      contextQueue,
+    };
+  };
+}

package/src/services/service-container.ts

@@ -2,43 +2,74 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Context } from 'effect';
+import { Layer, type Context } from 'effect';
 
 import { AiService } from './ai';
-import { CredentialsService } from './credentials';
+import { ConfiguredCredentialsService, CredentialsService } from './credentials';
 import { DatabaseService } from './database';
-import { QueuesService } from './queues';
+import { EventLogger } from './event-logger';
+import { FunctionCallService } from './function-call-service';
+import { QueueService } from './queues';
 import { TracingService } from './tracing';
 
-export interface Services {
-  database: Context.Tag.Service<DatabaseService>;
-  ai: Context.Tag.Service<AiService>;
-  queues: Context.Tag.Service<QueuesService>;
-  credentials: Context.Tag.Service<CredentialsService>;
-  tracing: Context.Tag.Service<TracingService>;
+/**
+ * List of all service tags and their names.
+ */
+export interface ServiceTagRecord {
+  ai: AiService;
+  credentials: CredentialsService;
+  database: DatabaseService;
+  eventLogger: EventLogger;
+  functionCallService: FunctionCallService;
+  tracing: TracingService;
+  queues: QueueService;
 }
 
-const SERVICE_MAPPING: Record<string, keyof Services> = {
-  [DatabaseService.key]: 'database',
+/**
+ * List of all services and their runtime types.
+ */
+export type ServiceRecord = {
+  [K in keyof ServiceTagRecord]: Context.Tag.Service<ServiceTagRecord[K]>;
+};
+
+/**
+ * Union of all services.
+ */
+export type Services = ServiceTagRecord[keyof ServiceTagRecord];
+
+const SERVICE_MAPPING: Record<string, keyof ServiceRecord> = {
   [AiService.key]: 'ai',
-  [QueuesService.key]: 'queues',
   [CredentialsService.key]: 'credentials',
+  [DatabaseService.key]: 'database',
+  [EventLogger.key]: 'eventLogger',
+  [FunctionCallService.key]: 'functionCallService',
+  [QueueService.key]: 'queues',
   [TracingService.key]: 'tracing',
 };
 
-const DEFAULT_SERVICES: Partial<Services> = {
+export const SERVICE_TAGS: Context.Tag<any, any>[] = [
+  AiService,
+  CredentialsService,
+  DatabaseService,
+  EventLogger,
+  FunctionCallService,
+  TracingService,
+  QueueService,
+];
+
+const DEFAULT_SERVICES: Partial<ServiceRecord> = {
   tracing: TracingService.noop,
 };
 
 export class ServiceContainer {
-  private _services: Partial<Services> = { ...DEFAULT_SERVICES };
+  private _services: Partial<ServiceRecord> = { ...DEFAULT_SERVICES };
 
   /**
    * Set services.
    * @param services - Services to set.
    * @returns The container instance.
    */
-  setServices(services: Partial<Services>): this {
+  setServices(services: Partial<ServiceRecord>): this {
     this._services = { ...this._services, ...services };
     return this;
   }
@@ -55,4 +86,24 @@ export class ServiceContainer {
   clone(): ServiceContainer {
     return new ServiceContainer().setServices({ ...this._services });
   }
+
+  // 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 database =
+      this._services.database != null
+        ? Layer.succeed(DatabaseService, this._services.database)
+        : DatabaseService.notAvailable;
+    const queues =
+      this._services.queues != null ? Layer.succeed(QueueService, this._services.queues) : QueueService.notAvailable;
+    const tracing = Layer.succeed(TracingService, this._services.tracing ?? TracingService.noop);
+    const eventLogger = Layer.succeed(EventLogger, this._services.eventLogger ?? EventLogger.noop);
+    const functionCallService = Layer.succeed(
+      FunctionCallService,
+      this._services.functionCallService ?? FunctionCallService.mock(),
+    );
+
+    return Layer.mergeAll(ai, credentials, database, queues, tracing, eventLogger, functionCallService);
+  }
 }

package/src/testing/index.ts

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

package/src/testing/logger.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, type Context } from 'effect';
+
+import { LogLevel } from '@dxos/log';
+
+import { type EventLogger, createEventLogger } from '../services';
+
+export const noopLogger: Context.Tag.Service<EventLogger> = {
+  log: () => Effect.succeed(undefined),
+  nodeId: undefined,
+};
+
+export const consoleLogger: Context.Tag.Service<EventLogger> = createEventLogger(LogLevel.INFO);

package/src/testing/services.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Context } from 'effect';
+
+import type { AiServiceClient } from '@dxos/ai';
+import type { QueueFactory } from '@dxos/echo-db';
+
+import { consoleLogger, noopLogger } from './logger';
+import { AiService, QueueService, ServiceContainer } from '../services';
+import type { EventLogger } from '../services/event-logger';
+
+export type TestServiceOptions = {
+  ai?: AiServiceClient;
+  queueFactory?: QueueFactory;
+  enableLogging?: boolean;
+  logger?: Context.Tag.Service<EventLogger>;
+};
+
+export const createTestServices = ({
+  ai,
+  queueFactory,
+  enableLogging = false,
+  logger = enableLogging ? consoleLogger : noopLogger,
+}: TestServiceOptions = {}): ServiceContainer => {
+  return new ServiceContainer().setServices({
+    ai: ai != null ? AiService.make(ai) : undefined,
+    eventLogger: logger,
+    queues: queueFactory != null ? QueueService.make(queueFactory, undefined) : undefined,
+  });
+};

package/src/trace.ts

@@ -4,8 +4,9 @@
 
 import { Schema } from 'effect';
 
+import { Type, type Ref } from '@dxos/echo';
 import { Queue } from '@dxos/echo-db';
-import { EchoObject, Expando, ObjectId, Ref } from '@dxos/echo-schema';
+import { ObjectId } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
 import { FunctionTrigger, type FunctionTriggerType } from './types';
@@ -52,16 +53,16 @@ export const InvocationTraceStartEvent = Schema.Struct({
   /**
    * Queue  for function/workflow invocation events.
    */
-  invocationTraceQueue: Ref(Queue),
+  invocationTraceQueue: Type.Ref(Queue),
   /**
    * DXN of the invoked function/workflow.
    */
-  invocationTarget: Ref(Expando),
+  invocationTarget: Type.Ref(Type.Expando),
   /**
    * Present for automatic invocations.
    */
-  trigger: Schema.optional(Ref(FunctionTrigger)),
-}).pipe(EchoObject({ typename: 'dxos.org/type/InvocationTraceStart', version: '0.1.0' }));
+  trigger: Schema.optional(Type.Ref(FunctionTrigger)),
+}).pipe(Type.Obj({ typename: 'dxos.org/type/InvocationTraceStart', version: '0.1.0' }));
 
 export type InvocationTraceStartEvent = Schema.Schema.Type<typeof InvocationTraceStartEvent>;
 
@@ -82,7 +83,7 @@ export const InvocationTraceEndEvent = Schema.Struct({
   timestampMs: Schema.Number,
   outcome: Schema.Enums(InvocationOutcome),
   exception: Schema.optional(TraceEventException),
-}).pipe(EchoObject({ typename: 'dxos.org/type/InvocationTraceEnd', version: '0.1.0' }));
+}).pipe(Type.Obj({ typename: 'dxos.org/type/InvocationTraceEnd', version: '0.1.0' }));
 
 export type InvocationTraceEndEvent = Schema.Schema.Type<typeof InvocationTraceEndEvent>;
 
@@ -106,24 +107,23 @@ export const TraceEvent = Schema.Struct({
   ingestionTimestampMs: Schema.Number,
   logs: Schema.Array(TraceEventLog),
   exceptions: Schema.Array(TraceEventException),
-}).pipe(EchoObject({ typename: 'dxos.org/type/TraceEvent', version: '0.1.0' }));
+}).pipe(Type.Obj({ typename: 'dxos.org/type/TraceEvent', version: '0.1.0' }));
 
 export type TraceEvent = Schema.Schema.Type<typeof TraceEvent>;
 
 /**
- * Deprecated InvocationTrace event format.
- * @deprecated
+ * InvocationTrace event format.
+ * This is the combined format of InvocationTraceStartEvent and InvocationTraceEndEvents for UI consumption.
  */
-// TODO(burdon): Remove.
 export type InvocationSpan = {
   id: string;
   timestampMs: number;
   outcome: InvocationOutcome;
   input: object;
   durationMs: number;
-  invocationTraceQueue: Ref<Queue>;
-  invocationTarget: Ref<Expando>;
-  trigger?: Ref<FunctionTriggerType>;
+  invocationTraceQueue: Ref.Ref<Queue>;
+  invocationTarget: Ref.Ref<Type.Expando>;
+  trigger?: Ref.Ref<FunctionTriggerType>;
   exception?: TraceEventException;
 };
 

package/src/translations.ts

@@ -2,13 +2,18 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Type } from '@dxos/echo';
+
 import { ScriptType } from './schema';
 
 export default [
   {
     'en-US': {
-      [ScriptType.typename]: {
+      [Type.getTypename(ScriptType)]: {
         'typename label': 'Script',
+        'typename label_zero': 'Scripts',
+        'typename label_one': 'Script',
+        'typename label_other': 'Scripts',
       },
     },
   },