@dxos/functions 0.8.4-main.f9ba587 → 0.8.4-main.fffef41

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

@@ -1,64 +0,0 @@
-//
-// 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/service-container.ts

@@ -1,127 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Layer, type Context } from 'effect';
-
-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';
-
-/**
- * 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;
-  toolResolver: ToolResolverService;
-}
-
-/**
- * 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',
-  [CredentialsService.key]: 'credentials',
-  [DatabaseService.key]: 'database',
-  [EventLogger.key]: 'eventLogger',
-  [FunctionCallService.key]: 'functionCallService',
-  [QueueService.key]: 'queues',
-  [TracingService.key]: 'tracing',
-  [ToolResolverService.key]: 'toolResolver',
-};
-
-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<ServiceRecord> = { ...DEFAULT_SERVICES };
-
-  /**
-   * Set services.
-   * @param services - Services to set.
-   * @returns The container instance.
-   */
-  setServices(services: Partial<ServiceRecord>): this {
-    this._services = { ...this._services, ...services };
-    return this;
-  }
-
-  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 T;
-  }
-
-  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(),
-    );
-    const toolResolver = Layer.succeed(
-      ToolResolverService,
-      this._services.toolResolver ?? ToolResolverService.notAvailable,
-    );
-
-    return Layer.mergeAll(
-      //
-      ai,
-      credentials,
-      database,
-      queues,
-      tracing,
-      eventLogger,
-      functionCallService,
-      toolResolver,
-    );
-  }
-}

package/src/services/tool-resolver.ts

@@ -1,31 +0,0 @@
-//
-// 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/index.ts

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

package/src/testing/logger.ts

@@ -1,16 +0,0 @@
-//
-// 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

@@ -1,174 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Context } from 'effect';
-
-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,
-  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 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,
-  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: 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/trace.ts

@@ -1,180 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Type, type Ref } from '@dxos/echo';
-import { Queue } from '@dxos/echo-db';
-import { ObjectId } from '@dxos/echo-schema';
-import { log } from '@dxos/log';
-
-import { FunctionTrigger, type FunctionTriggerType } from './types';
-
-export enum InvocationOutcome {
-  SUCCESS = 'success',
-  FAILURE = 'failure',
-  PENDING = 'pending',
-}
-
-// TODO(burdon): Convert to extensible discriminated union of EDGE events.
-export enum InvocationTraceEventType {
-  START = 'start',
-  END = 'end',
-}
-
-export const TraceEventException = Schema.Struct({
-  timestampMs: Schema.Number,
-  message: Schema.String,
-  name: Schema.String,
-  stack: Schema.optional(Schema.String),
-});
-export type TraceEventException = Schema.Schema.Type<typeof TraceEventException>;
-
-export const InvocationTraceStartEvent = Schema.Struct({
-  /**
-   * Queue message id.
-   */
-  id: ObjectId,
-  type: Schema.Literal(InvocationTraceEventType.START),
-  /**
-   * Invocation id, the same for invocation start and end events.
-   */
-  invocationId: ObjectId,
-  /**
-   * Event generation time.
-   */
-  timestampMs: Schema.Number,
-  /**
-   * Data passed to function / workflow as an argument.
-   */
-  // TODO(burdon): Input schema?
-  input: Schema.Object,
-  /**
-   * Queue  for function/workflow invocation events.
-   */
-  invocationTraceQueue: Type.Ref(Queue),
-  /**
-   * DXN of the invoked function/workflow.
-   */
-  invocationTarget: Type.Ref(Type.Expando),
-  /**
-   * Present for automatic invocations.
-   */
-  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>;
-
-export const InvocationTraceEndEvent = Schema.Struct({
-  /**
-   * Trace event id.
-   */
-  id: ObjectId,
-  type: Schema.Literal(InvocationTraceEventType.END),
-  /**
-   * Invocation id, will be the same for invocation start and end.
-   */
-  invocationId: ObjectId,
-  /**
-   * Event generation time.
-   */
-  // TODO(burdon): Remove ms suffix.
-  timestampMs: Schema.Number,
-  outcome: Schema.Enums(InvocationOutcome),
-  exception: Schema.optional(TraceEventException),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/InvocationTraceEnd', version: '0.1.0' }));
-
-export type InvocationTraceEndEvent = Schema.Schema.Type<typeof InvocationTraceEndEvent>;
-
-export type InvocationTraceEvent = InvocationTraceStartEvent | InvocationTraceEndEvent;
-
-export const TraceEventLog = Schema.Struct({
-  timestampMs: Schema.Number,
-  level: Schema.String,
-  message: Schema.String,
-  context: Schema.optional(Schema.Object),
-});
-
-export const TraceEvent = Schema.Struct({
-  id: ObjectId,
-  // TODO(burdon): Need enum/numeric result (not string).
-  outcome: Schema.String,
-  truncated: Schema.Boolean,
-  /**
-   * Time when the event was persisted.
-   */
-  ingestionTimestampMs: Schema.Number,
-  logs: Schema.Array(TraceEventLog),
-  exceptions: Schema.Array(TraceEventException),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/TraceEvent', version: '0.1.0' }));
-
-export type TraceEvent = Schema.Schema.Type<typeof TraceEvent>;
-
-/**
- * InvocationTrace event format.
- * This is the combined format of InvocationTraceStartEvent and InvocationTraceEndEvents for UI consumption.
- */
-export type InvocationSpan = {
-  id: string;
-  timestampMs: number;
-  outcome: InvocationOutcome;
-  input: object;
-  durationMs: number;
-  invocationTraceQueue: Ref.Ref<Queue>;
-  invocationTarget: Ref.Ref<Type.Expando>;
-  trigger?: Ref.Ref<FunctionTriggerType>;
-  exception?: TraceEventException;
-};
-
-export const createInvocationSpans = (items?: InvocationTraceEvent[]): InvocationSpan[] => {
-  if (!items) {
-    return [];
-  }
-
-  const eventsByInvocationId = new Map<string, { start?: InvocationTraceStartEvent; end?: InvocationTraceEndEvent }>();
-  for (const event of items) {
-    if (!('invocationId' in event)) {
-      // Skip legacy format entries.
-      continue;
-    }
-
-    const invocationId = event.invocationId;
-    const entry = eventsByInvocationId.get(invocationId) || { start: undefined, end: undefined };
-    if (event.type === InvocationTraceEventType.START) {
-      entry.start = event as InvocationTraceStartEvent;
-    } else if (event.type === InvocationTraceEventType.END) {
-      entry.end = event as InvocationTraceEndEvent;
-    }
-
-    eventsByInvocationId.set(invocationId, entry);
-  }
-
-  const now = Date.now();
-  const result: InvocationSpan[] = [];
-
-  // Create spans for each invocation
-  for (const [invocationId, { start, end }] of eventsByInvocationId.entries()) {
-    if (!start) {
-      // No start event, can't create a meaningful span
-      log.warn('found end event without matching start', { invocationId });
-      continue;
-    }
-
-    const isInProgress = end === undefined;
-
-    result.push({
-      id: invocationId,
-      timestampMs: start.timestampMs,
-      durationMs: isInProgress ? now - start.timestampMs : end!.timestampMs - start.timestampMs,
-      outcome: end?.outcome ?? InvocationOutcome.PENDING,
-      exception: end?.exception,
-      input: start.input,
-      invocationTraceQueue: start.invocationTraceQueue,
-      invocationTarget: start.invocationTarget,
-      trigger: start.trigger,
-    });
-  }
-
-  return result;
-};

package/src/translations.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { type Resource } from 'i18next';
-
-import { ScriptType } from './schema';
-
-export const translations = [
-  {
-    'en-US': {
-      [ScriptType.typename]: {
-        'typename label': 'Script',
-        'typename label_zero': 'Scripts',
-        'typename label_one': 'Script',
-        'typename label_other': 'Scripts',
-      },
-    },
-  },
-] as const satisfies Resource[];