@dxos/functions 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

package/dist/lib/browser/chunk-M6EXIREF.mjs

@@ -1,610 +0,0 @@
-// src/errors.ts
-import { BaseError } from "@dxos/errors";
-var ServiceNotAvailableError = class extends BaseError.extend("SERVICE_NOT_AVAILABLE", "Service not available") {
-  constructor(service, options) {
-    super({
-      context: {
-        service
-      },
-      ...options
-    });
-  }
-};
-var FunctionNotFoundError = class extends BaseError.extend("FUNCTION_NOT_FOUND", "Function not found") {
-  constructor(functionKey, options) {
-    super({
-      context: {
-        function: functionKey
-      },
-      ...options
-    });
-  }
-};
-var FunctionError = class extends BaseError.extend("FUNCTION_ERROR", "Function invocation error") {
-};
-var TriggerStateNotFoundError = class extends BaseError.extend("TRIGGER_STATE_NOT_FOUND", "Trigger state not found") {
-};
-
-// src/url.ts
-var FUNCTIONS_META_KEY = "dxos.org/service/function";
-var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
-var isSecure = (protocol) => {
-  return protocol === "https:" || protocol === "wss:";
-};
-var getUserFunctionIdInMetadata = (meta) => {
-  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
-};
-var setUserFunctionIdInMetadata = (meta, functionId) => {
-  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
-  if (key) {
-    if (key.id !== functionId) {
-      throw new Error("Metadata mismatch");
-    }
-  } else {
-    meta.keys.push({
-      source: FUNCTIONS_META_KEY,
-      id: functionId
-    });
-  }
-};
-var getInvocationUrl = (functionId, edgeUrl, options = {}) => {
-  const baseUrl = new URL("functions/", edgeUrl);
-  const url = new URL(`./${functionId}`, 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();
-};
-
-// src/services/database.ts
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import { Obj, ObjectNotFoundError } from "@dxos/echo";
-import { promiseWithCauseCapture } from "@dxos/effect";
-import { invariant } from "@dxos/invariant";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/database.ts";
-var DatabaseService = class _DatabaseService extends Context.Tag("@dxos/functions/DatabaseService")() {
-  static notAvailable = Layer.succeed(_DatabaseService, {
-    get db() {
-      throw new Error("Database not available");
-    }
-  });
-  static make = (db) => {
-    return {
-      get db() {
-        return db;
-      }
-    };
-  };
-  static layer = (db) => {
-    return Layer.succeed(_DatabaseService, _DatabaseService.make(db));
-  };
-  /**
-  * Resolves an object by its DXN.
-  */
-  static resolve = (dxn, schema) => Effect.gen(function* () {
-    const { db } = yield* _DatabaseService;
-    const object = yield* promiseWithCauseCapture(() => db.graph.createRefResolver({
-      context: {
-        space: db.spaceId
-      }
-    }).resolve(dxn));
-    if (!object) {
-      return yield* Effect.fail(new ObjectNotFoundError(dxn));
-    }
-    invariant(!schema || Obj.instanceOf(schema, object), "Object type mismatch.", {
-      F: __dxlog_file,
-      L: 82,
-      S: this,
-      A: [
-        "!schema || Obj.instanceOf(schema, object)",
-        "'Object type mismatch.'"
-      ]
-    });
-    return object;
-  });
-  /**
-  * Loads an object reference.
-  */
-  static load = Effect.fn(function* (ref) {
-    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
-    if (!object) {
-      return yield* Effect.fail(new ObjectNotFoundError(ref.dxn));
-    }
-    return object;
-  });
-  /**
-  * Loads an object reference option.
-  */
-  // TODO(burdon): Option?
-  static loadOption = Effect.fn(function* (ref) {
-    const object = yield* _DatabaseService.load(ref).pipe(Effect.catchTag("OBJECT_NOT_FOUND", () => Effect.succeed(void 0)));
-    return Option.fromNullable(object);
-  });
-  // TODO(burdon): Can we create a proxy for the following methods on EchoDatabase? Use @inheritDoc?
-  // TODO(burdon): Figure out how to chain query().run();
-  /**
-  * @link EchoDatabase.add
-  */
-  static add = (obj) => _DatabaseService.pipe(Effect.map(({ db }) => db.add(obj)));
-  /**
-  * @link EchoDatabase.remove
-  */
-  static remove = (obj) => _DatabaseService.pipe(Effect.map(({ db }) => db.remove(obj)));
-  /**
-  * @link EchoDatabase.flush
-  */
-  static flush = (opts) => _DatabaseService.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));
-  /**
-  * @link EchoDatabase.getObjectById
-  */
-  static getObjectById = (id) => {
-    return _DatabaseService.pipe(Effect.map(({ db }) => db.getObjectById(id)));
-  };
-  /**
-  * Creates a `QueryResult` object that can be subscribed to.
-  */
-  static query = (queryOrFilter) => _DatabaseService.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("DatabaseService.query"));
-  /**
-  * Executes the query once and returns the results.
-  */
-  static runQuery = (queryOrFilter) => _DatabaseService.query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
-  static schemaQuery = (query) => _DatabaseService.pipe(Effect.map(({ db }) => db.schemaRegistry.query(query)), Effect.withSpan("DatabaseService.schemaQuery"));
-  static runSchemaQuery = (query) => _DatabaseService.schemaQuery(query).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
-};
-
-// src/services/credentials.ts
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as Context2 from "effect/Context";
-import * as Effect2 from "effect/Effect";
-import * as Layer2 from "effect/Layer";
-import * as Redacted from "effect/Redacted";
-import { Query } from "@dxos/echo";
-import { DataType } from "@dxos/schema";
-var CredentialsService = class _CredentialsService extends Context2.Tag("@dxos/functions/CredentialsService")() {
-  static getCredential = (query) => Effect2.gen(function* () {
-    const credentials = yield* _CredentialsService;
-    return yield* Effect2.promise(() => credentials.getCredential(query));
-  });
-  static getApiKey = (query) => Effect2.gen(function* () {
-    const credential = yield* _CredentialsService.getCredential(query);
-    if (!credential.apiKey) {
-      throw new Error(`API key not found for service: ${query.service}`);
-    }
-    return Redacted.make(credential.apiKey);
-  });
-  static configuredLayer = (credentials) => Layer2.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
-  static layerConfig = (credentials) => Layer2.effect(_CredentialsService, Effect2.gen(function* () {
-    const serviceCredentials = yield* Effect2.forEach(credentials, ({ service, apiKey }) => Effect2.gen(function* () {
-      return {
-        service,
-        apiKey: Redacted.value(yield* apiKey)
-      };
-    }));
-    return new ConfiguredCredentialsService(serviceCredentials);
-  }));
-  static layerFromDatabase = () => Layer2.effect(_CredentialsService, Effect2.gen(function* () {
-    const dbService = yield* DatabaseService;
-    const queryCredentials = async (query) => {
-      const { objects: accessTokens } = await dbService.db.query(Query.type(DataType.AccessToken)).run();
-      return accessTokens.filter((accessToken) => accessToken.source === query.service).map((accessToken) => ({
-        service: accessToken.source,
-        apiKey: accessToken.token
-      }));
-    };
-    return {
-      getCredential: async (query) => {
-        const credentials = await queryCredentials(query);
-        if (credentials.length === 0) {
-          throw new Error(`Credential not found for service: ${query.service}`);
-        }
-        return credentials[0];
-      },
-      queryCredentials: async (query) => {
-        return queryCredentials(query);
-      }
-    };
-  }));
-};
-var ConfiguredCredentialsService = class {
-  credentials;
-  constructor(credentials = []) {
-    this.credentials = credentials;
-  }
-  addCredentials(credentials) {
-    this.credentials.push(...credentials);
-    return this;
-  }
-  async queryCredentials(query) {
-    return this.credentials.filter((credential) => credential.service === query.service);
-  }
-  async getCredential(query) {
-    const credential = this.credentials.find((credential2) => credential2.service === query.service);
-    if (!credential) {
-      throw new Error(`Credential not found for service: ${query.service}`);
-    }
-    return credential;
-  }
-};
-var withAuthorization = (query, kind) => HttpClient.mapRequestEffect(Effect2.fnUntraced(function* (request) {
-  const key = yield* CredentialsService.getApiKey(query).pipe(Effect2.map(Redacted.value));
-  const authorization = kind ? `${kind} ${key}` : key;
-  return HttpClientRequest.setHeader(request, "Authorization", authorization);
-}));
-
-// src/services/tracing.ts
-import * as Context3 from "effect/Context";
-import * as Effect3 from "effect/Effect";
-import * as Layer3 from "effect/Layer";
-import { AgentStatus } from "@dxos/ai";
-import { Obj as Obj2 } from "@dxos/echo";
-import { log } from "@dxos/log";
-import { DataType as DataType2 } from "@dxos/schema";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/services/tracing.ts";
-var TracingService = class _TracingService extends Context3.Tag("@dxos/functions/TracingService")() {
-  static noop = {
-    write: () => {
-    },
-    getTraceContext: () => ({})
-  };
-  static layerNoop = Layer3.succeed(_TracingService, _TracingService.noop);
-  static console = {
-    write: (event) => {
-      console.log(event);
-    },
-    getTraceContext: () => ({})
-  };
-  static layerConsole = Layer3.succeed(_TracingService, _TracingService.console);
-  static layerLogInfo = () => Layer3.succeed(_TracingService, {
-    write: (event) => {
-      if (Obj2.instanceOf(AgentStatus, event)) {
-        log.info("status", {
-          message: event.message
-        }, {
-          F: __dxlog_file2,
-          L: 52,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    },
-    getTraceContext: () => ({})
-  });
-  /**
-  * Creates a TracingService layer that emits events to the parent tracing service.
-  */
-  static layerSubframe = (mapContext) => Layer3.effect(_TracingService, Effect3.gen(function* () {
-    const tracing = yield* _TracingService;
-    const context = mapContext(tracing.getTraceContext());
-    return {
-      write: (event) => tracing.write(event),
-      getTraceContext: () => context
-    };
-  }));
-  static layerQueue = (queue) => Layer3.effect(_TracingService, Effect3.gen(function* () {
-    return {
-      write: (event) => queue.append([
-        event
-      ]),
-      getTraceContext: () => ({
-        debugInfo: {
-          queue: queue.dxn.toString()
-        }
-      })
-    };
-  }));
-  /**
-  * Emit the current human-readable execution status.
-  */
-  static emitStatus = Effect3.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj2.make(AgentStatus, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      toolCallId: tracing.getTraceContext().toolCallId,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      ...data
-    }));
-  });
-  static emitConverationMessage = Effect3.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj2.make(DataType2.Message, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      ...data,
-      properties: {
-        [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
-        ...data.properties
-      }
-    }));
-  });
-};
-var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
-
-// src/services/event-logger.ts
-import * as Context4 from "effect/Context";
-import * as Effect4 from "effect/Effect";
-import * as Layer4 from "effect/Layer";
-import * as Schema from "effect/Schema";
-import { Obj as Obj3, Type } from "@dxos/echo";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { LogLevel, log as log2 } from "@dxos/log";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/services/event-logger.ts";
-var ComputeEventPayload = Schema.Union(Schema.Struct({
-  type: Schema.Literal("begin-compute"),
-  nodeId: Schema.String,
-  inputs: Schema.Record({
-    key: Schema.String,
-    value: Schema.Any
-  })
-}), Schema.Struct({
-  type: Schema.Literal("end-compute"),
-  nodeId: Schema.String,
-  outputs: Schema.Record({
-    key: Schema.String,
-    value: Schema.Any
-  })
-}), Schema.Struct({
-  type: Schema.Literal("compute-input"),
-  nodeId: Schema.String,
-  property: Schema.String,
-  value: Schema.Any
-}), Schema.Struct({
-  type: Schema.Literal("compute-output"),
-  nodeId: Schema.String,
-  property: Schema.String,
-  value: Schema.Any
-}), Schema.Struct({
-  type: Schema.Literal("custom"),
-  nodeId: Schema.String,
-  event: Schema.Any
-}));
-var ComputeEvent = Schema.Struct({
-  payload: ComputeEventPayload
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/ComputeEvent",
-  version: "0.1.0"
-}));
-var ComputeEventLogger = class _ComputeEventLogger extends Context4.Tag("@dxos/functions/ComputeEventLogger")() {
-  static noop = {
-    log: () => {
-    },
-    nodeId: void 0
-  };
-  /**
-  * Implements ComputeEventLogger using TracingService.
-  */
-  static layerFromTracing = Layer4.effect(_ComputeEventLogger, Effect4.gen(function* () {
-    const tracing = yield* TracingService;
-    return {
-      log: (event) => {
-        tracing.write(Obj3.make(ComputeEvent, {
-          payload: event
-        }));
-      },
-      nodeId: void 0
-    };
-  }));
-};
-var logCustomEvent = (data) => Effect4.gen(function* () {
-  const logger = yield* ComputeEventLogger;
-  if (!logger.nodeId) {
-    throw new Error("logCustomEvent must be called within a node compute function");
-  }
-  logger.log({
-    type: "custom",
-    nodeId: logger.nodeId,
-    event: data
-  });
-});
-var createDefectLogger = () => Effect4.catchAll((error) => Effect4.gen(function* () {
-  log2.error("unhandled effect error", {
-    error
-  }, {
-    F: __dxlog_file3,
-    L: 96,
-    S: this,
-    C: (f, a) => f(...a)
-  });
-  throw error;
-}));
-var createEventLogger = (level, message = "event") => {
-  const logFunction = {
-    [LogLevel.WARN]: log2.warn,
-    [LogLevel.VERBOSE]: log2.verbose,
-    [LogLevel.DEBUG]: log2.debug,
-    [LogLevel.INFO]: log2.info,
-    [LogLevel.ERROR]: log2.error
-  }[level];
-  invariant2(logFunction, void 0, {
-    F: __dxlog_file3,
-    L: 114,
-    S: void 0,
-    A: [
-      "logFunction",
-      ""
-    ]
-  });
-  return {
-    log: (event) => {
-      logFunction(message, event);
-    },
-    nodeId: void 0
-  };
-};
-
-// src/services/queues.ts
-import * as Context5 from "effect/Context";
-import * as Effect5 from "effect/Effect";
-import * as Layer5 from "effect/Layer";
-var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/QueueService")() {
-  static notAvailable = Layer5.succeed(_QueueService, {
-    queues: {
-      get(_dxn) {
-        throw new Error("Queues not available");
-      },
-      create() {
-        throw new Error("Queues not available");
-      }
-    },
-    queue: void 0
-  });
-  static make = (queues, queue) => {
-    return {
-      queues,
-      queue
-    };
-  };
-  static layer = (queues, queue) => Layer5.succeed(_QueueService, _QueueService.make(queues, queue));
-  /**
-  * Gets a queue by its DXN.
-  */
-  static getQueue = (dxn) => _QueueService.pipe(Effect5.map(({ queues }) => queues.get(dxn)));
-  /**
-  * Creates a new queue.
-  */
-  static createQueue = (options) => _QueueService.pipe(Effect5.map(({ queues }) => queues.create(options)));
-  static append = (queue, objects) => Effect5.promise(() => queue.append(objects));
-};
-var ContextQueueService = class _ContextQueueService extends Context5.Tag("@dxos/functions/ContextQueueService")() {
-  static layer = (queue) => Layer5.succeed(_ContextQueueService, {
-    queue
-  });
-};
-
-// src/services/remote-function-execution-service.ts
-import * as Context6 from "effect/Context";
-import * as Effect6 from "effect/Effect";
-import * as Layer6 from "effect/Layer";
-var RemoteFunctionExecutionService = class _RemoteFunctionExecutionService extends Context6.Tag("@dxos/functions/RemoteFunctionExecutionService")() {
-  /**
-  * @param baseUrl URL of the EDGE server.
-  * @param spaceId - The space ID to invoke the function in. If not provided, the function will be without space context.
-  * @returns
-  */
-  static fromClient(baseUrl, spaceId) {
-    return Layer6.succeed(_RemoteFunctionExecutionService, {
-      callFunction: (deployedFunctionId, input) => Effect6.gen(function* () {
-        const url = getInvocationUrl(deployedFunctionId, baseUrl, {
-          spaceId
-        });
-        const result = yield* Effect6.promise(() => fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(input)
-        }));
-        if (result.status >= 300 || result.status < 200) {
-          const text = yield* Effect6.promise(() => result.text());
-          return yield* Effect6.die(new FunctionError({
-            message: "Failed to invoke function",
-            cause: new Error(`HTTP error: ${text}`)
-          }));
-        }
-        const data = yield* Effect6.promise(() => result.json());
-        return data;
-      })
-    });
-  }
-  static mock = () => {
-    return {
-      callFunction: (deployedFunctionId, input) => Effect6.succeed(input)
-    };
-  };
-  static layerMock = Layer6.succeed(_RemoteFunctionExecutionService, _RemoteFunctionExecutionService.mock());
-};
-
-// src/services/service-container.ts
-import * as Layer7 from "effect/Layer";
-import { AiService } from "@dxos/ai";
-import { entries } from "@dxos/util";
-var SERVICES = {
-  ai: AiService.AiService,
-  credentials: CredentialsService,
-  database: DatabaseService,
-  eventLogger: ComputeEventLogger,
-  functionCallService: RemoteFunctionExecutionService,
-  queues: QueueService,
-  tracing: TracingService
-};
-var SERVICE_MAPPING = Object.fromEntries(entries(SERVICES).map(([name, tag]) => [
-  tag.key,
-  name
-]));
-var SERVICE_TAGS = Object.values(SERVICES);
-var DEFAULT_SERVICES = {
-  tracing: TracingService.noop
-};
-var ServiceContainer = class _ServiceContainer {
-  _services = {
-    ...DEFAULT_SERVICES
-  };
-  /**
-  * Set services.
-  * @param services - Services to set.
-  * @returns The container instance.
-  */
-  setServices(services) {
-    this._services = {
-      ...this._services,
-      ...services
-    };
-    return this;
-  }
-  getService(tag) {
-    const serviceKey = SERVICE_MAPPING[tag.key];
-    const service = serviceKey != null ? this._services[serviceKey] : void 0;
-    if (!service) {
-      throw new Error(`Service not available: ${tag.key}`);
-    }
-    return service;
-  }
-  clone() {
-    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() {
-    const ai = this._services.ai != null ? Layer7.succeed(AiService.AiService, this._services.ai) : AiService.notAvailable;
-    const credentials = Layer7.succeed(CredentialsService, this._services.credentials ?? new ConfiguredCredentialsService());
-    const database = this._services.database != null ? Layer7.succeed(DatabaseService, this._services.database) : DatabaseService.notAvailable;
-    const queues = this._services.queues != null ? Layer7.succeed(QueueService, this._services.queues) : QueueService.notAvailable;
-    const tracing = Layer7.succeed(TracingService, this._services.tracing ?? TracingService.noop);
-    const eventLogger = Layer7.succeed(ComputeEventLogger, this._services.eventLogger ?? ComputeEventLogger.noop);
-    const functionCallService = Layer7.succeed(RemoteFunctionExecutionService, this._services.functionCallService ?? RemoteFunctionExecutionService.mock());
-    return Layer7.mergeAll(ai, credentials, database, queues, tracing, eventLogger, functionCallService);
-  }
-};
-
-export {
-  ServiceNotAvailableError,
-  FunctionNotFoundError,
-  FunctionError,
-  TriggerStateNotFoundError,
-  FUNCTIONS_META_KEY,
-  FUNCTIONS_PRESET_META_KEY,
-  getUserFunctionIdInMetadata,
-  setUserFunctionIdInMetadata,
-  getInvocationUrl,
-  DatabaseService,
-  CredentialsService,
-  ConfiguredCredentialsService,
-  withAuthorization,
-  TracingService,
-  MESSAGE_PROPERTY_TOOL_CALL_ID,
-  ComputeEventPayload,
-  ComputeEvent,
-  ComputeEventLogger,
-  logCustomEvent,
-  createDefectLogger,
-  createEventLogger,
-  QueueService,
-  ContextQueueService,
-  RemoteFunctionExecutionService,
-  SERVICE_TAGS,
-  ServiceContainer
-};
-//# sourceMappingURL=chunk-M6EXIREF.mjs.map