@dxos/functions 0.8.4-main.b97322e → 0.8.4-main.dedc0f3

package/dist/lib/node-esm/chunk-MPKVY7ZR.mjs

@@ -0,0 +1,625 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// 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 { Context, Effect, Layer, Option } from "effect";
+import { Obj } from "@dxos/echo";
+import { promiseWithCauseCapture } from "@dxos/effect";
+import { BaseError } from "@dxos/errors";
+import { invariant } from "@dxos/invariant";
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/database.ts";
+var _Context_Tag;
+var DatabaseService = class extends (_Context_Tag = Context.Tag("@dxos/functions/DatabaseService")()) {
+};
+_define_property(DatabaseService, "notAvailable", Layer.succeed(DatabaseService, {
+  get db() {
+    throw new Error("Database not available");
+  }
+}));
+_define_property(DatabaseService, "make", (db) => {
+  return {
+    get db() {
+      return db;
+    }
+  };
+});
+_define_property(DatabaseService, "layer", (db) => {
+  return Layer.succeed(DatabaseService, DatabaseService.make(db));
+});
+_define_property(DatabaseService, "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: 70,
+    S: this,
+    A: [
+      "!schema || Obj.instanceOf(schema, object)",
+      "'Object type mismatch.'"
+    ]
+  });
+  return object;
+}));
+_define_property(DatabaseService, "load", Effect.fn(function* (ref) {
+  const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
+  if (!object) {
+    return yield* Effect.fail(new ObjectNotFoundError({
+      dxn: ref.dxn
+    }));
+  }
+  return object;
+}));
+_define_property(DatabaseService, "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);
+}));
+_define_property(DatabaseService, "add", (obj) => DatabaseService.pipe(Effect.map(({ db }) => db.add(obj))));
+_define_property(DatabaseService, "remove", (obj) => DatabaseService.pipe(Effect.map(({ db }) => db.remove(obj))));
+_define_property(DatabaseService, "flush", (opts) => DatabaseService.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))));
+_define_property(DatabaseService, "getObjectById", (id) => {
+  return DatabaseService.pipe(Effect.map(({ db }) => db.getObjectById(id)));
+});
+_define_property(DatabaseService, "query", (queryOrFilter) => DatabaseService.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("DatabaseService.query")));
+_define_property(DatabaseService, "runQuery", (queryOrFilter) => DatabaseService.query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run()))));
+_define_property(DatabaseService, "schemaQuery", (query) => DatabaseService.pipe(Effect.map(({ db }) => db.schemaRegistry.query(query)), Effect.withSpan("DatabaseService.schemaQuery")));
+_define_property(DatabaseService, "runSchemaQuery", (query) => DatabaseService.schemaQuery(query).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run()))));
+var ObjectNotFoundError = class extends BaseError.extend("OBJECT_NOT_FOUND") {
+  constructor(context) {
+    super("Object not found", {
+      context
+    });
+  }
+};
+
+// src/services/queues.ts
+import { Context as Context2, Effect as Effect2, Layer as Layer2 } from "effect";
+function _define_property2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var _Context_Tag2;
+var QueueService = class extends (_Context_Tag2 = Context2.Tag("@dxos/functions/QueueService")()) {
+};
+_define_property2(QueueService, "notAvailable", Layer2.succeed(QueueService, {
+  queues: {
+    get(_dxn) {
+      throw new Error("Queues not available");
+    },
+    create() {
+      throw new Error("Queues not available");
+    }
+  },
+  queue: void 0
+}));
+_define_property2(QueueService, "make", (queues, queue) => {
+  return {
+    queues,
+    queue
+  };
+});
+_define_property2(QueueService, "layer", (queues, queue) => Layer2.succeed(QueueService, QueueService.make(queues, queue)));
+_define_property2(QueueService, "getQueue", (dxn) => QueueService.pipe(Effect2.map(({ queues }) => queues.get(dxn))));
+_define_property2(QueueService, "createQueue", (options) => QueueService.pipe(Effect2.map(({ queues }) => queues.create(options))));
+_define_property2(QueueService, "append", (queue, objects) => Effect2.promise(() => queue.append(objects)));
+var _Context_Tag1;
+var ContextQueueService = class extends (_Context_Tag1 = Context2.Tag("@dxos/functions/ContextQueueService")()) {
+};
+_define_property2(ContextQueueService, "layer", (queue) => Layer2.succeed(ContextQueueService, {
+  queue
+}));
+
+// src/services/credentials.ts
+import { HttpClient, HttpClientRequest } from "@effect/platform";
+import { Context as Context3, Effect as Effect3, Layer as Layer3, Redacted } from "effect";
+import { Query } from "@dxos/echo";
+import { DataType } from "@dxos/schema";
+function _define_property3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var _Context_Tag3;
+var CredentialsService = class extends (_Context_Tag3 = Context3.Tag("@dxos/functions/CredentialsService")()) {
+};
+_define_property3(CredentialsService, "getCredential", (query) => Effect3.gen(function* () {
+  const credentials = yield* CredentialsService;
+  return yield* Effect3.promise(() => credentials.getCredential(query));
+}));
+_define_property3(CredentialsService, "getApiKey", (query) => Effect3.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);
+}));
+_define_property3(CredentialsService, "configuredLayer", (credentials) => Layer3.succeed(CredentialsService, new ConfiguredCredentialsService(credentials)));
+_define_property3(CredentialsService, "layerConfig", (credentials) => Layer3.effect(CredentialsService, Effect3.gen(function* () {
+  const serviceCredentials = yield* Effect3.forEach(credentials, ({ service, apiKey }) => Effect3.gen(function* () {
+    return {
+      service,
+      apiKey: Redacted.value(yield* apiKey)
+    };
+  }));
+  return new ConfiguredCredentialsService(serviceCredentials);
+})));
+_define_property3(CredentialsService, "layerFromDatabase", () => Layer3.effect(CredentialsService, Effect3.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 {
+  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;
+  }
+  constructor(credentials = []) {
+    _define_property3(this, "credentials", void 0);
+    this.credentials = credentials;
+  }
+};
+var withAuthorization = (query, kind) => HttpClient.mapRequestEffect(Effect3.fnUntraced(function* (request) {
+  const key = yield* CredentialsService.getApiKey(query).pipe(Effect3.map(Redacted.value));
+  const authorization = kind ? `${kind} ${key}` : key;
+  return HttpClientRequest.setHeader(request, "Authorization", authorization);
+}));
+
+// src/services/tracing.ts
+import { Context as Context4, Effect as Effect4, Layer as Layer4 } from "effect";
+import { AgentStatus } from "@dxos/ai";
+import { Obj as Obj2 } from "@dxos/echo";
+import { log } from "@dxos/log";
+import { DataType as DataType2 } from "@dxos/schema";
+function _define_property4(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/services/tracing.ts";
+var _Context_Tag4;
+var TracingService = class extends (_Context_Tag4 = Context4.Tag("@dxos/functions/TracingService")()) {
+};
+_define_property4(TracingService, "noop", {
+  write: () => {
+  },
+  getTraceContext: () => ({})
+});
+_define_property4(TracingService, "layerNoop", Layer4.succeed(TracingService, TracingService.noop));
+_define_property4(TracingService, "console", {
+  write: (event) => {
+    console.log(event);
+  },
+  getTraceContext: () => ({})
+});
+_define_property4(TracingService, "layerConsole", Layer4.succeed(TracingService, TracingService.console));
+_define_property4(TracingService, "layerLogInfo", () => Layer4.succeed(TracingService, {
+  write: (event) => {
+    if (Obj2.instanceOf(AgentStatus, event)) {
+      log.info("status", {
+        message: event.message
+      }, {
+        F: __dxlog_file2,
+        L: 51,
+        S: TracingService,
+        C: (f, a) => f(...a)
+      });
+    }
+  },
+  getTraceContext: () => ({})
+}));
+_define_property4(TracingService, "layerSubframe", (mapContext) => Layer4.effect(TracingService, Effect4.gen(function* () {
+  const tracing = yield* TracingService;
+  const context = mapContext(tracing.getTraceContext());
+  return {
+    write: (event) => tracing.write(event),
+    getTraceContext: () => context
+  };
+})));
+_define_property4(TracingService, "layerQueue", (queue) => Layer4.effect(TracingService, Effect4.gen(function* () {
+  return {
+    write: (event) => queue.append([
+      event
+    ]),
+    getTraceContext: () => ({
+      debugInfo: {
+        queue: queue.dxn.toString()
+      }
+    })
+  };
+})));
+_define_property4(TracingService, "emitStatus", Effect4.fnUntraced(function* (data) {
+  const tracing = yield* TracingService;
+  tracing.write(Obj2.make(AgentStatus, {
+    parentMessage: tracing.getTraceContext().parentMessage,
+    toolCallId: tracing.getTraceContext().toolCallId,
+    ...data
+  }));
+}));
+_define_property4(TracingService, "emitConverationMessage", Effect4.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 { Context as Context5, Effect as Effect5, Layer as Layer5, Schema } from "effect";
+import { Obj as Obj3, Type } from "@dxos/echo";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { LogLevel, log as log2 } from "@dxos/log";
+function _define_property5(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+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 _Context_Tag5;
+var ComputeEventLogger = class extends (_Context_Tag5 = Context5.Tag("@dxos/functions/ComputeEventLogger")()) {
+};
+_define_property5(ComputeEventLogger, "noop", {
+  log: () => {
+  },
+  nodeId: void 0
+});
+_define_property5(ComputeEventLogger, "layerFromTracing", Layer5.effect(ComputeEventLogger, Effect5.gen(function* () {
+  const tracing = yield* TracingService;
+  return {
+    log: (event) => {
+      tracing.write(Obj3.make(ComputeEvent, {
+        payload: event
+      }));
+    },
+    nodeId: void 0
+  };
+})));
+var logCustomEvent = (data) => Effect5.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 = () => Effect5.catchAll((error) => Effect5.gen(function* () {
+  log2.error("unhandled effect error", {
+    error
+  }, {
+    F: __dxlog_file3,
+    L: 93,
+    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: 111,
+    S: void 0,
+    A: [
+      "logFunction",
+      ""
+    ]
+  });
+  return {
+    log: (event) => {
+      logFunction(message, event);
+    },
+    nodeId: void 0
+  };
+};
+
+// src/services/remote-function-execution-service.ts
+import { Context as Context6, Layer as Layer6 } from "effect";
+function _define_property6(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var _Context_Tag6;
+var RemoteFunctionExecutionService = class extends (_Context_Tag6 = Context6.Tag("@dxos/functions/RemoteFunctionExecutionService")()) {
+  static fromClient(baseUrl, spaceId) {
+    return {
+      callFunction: async (deployedFunctionId, input) => {
+        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();
+      }
+    };
+  }
+};
+_define_property6(RemoteFunctionExecutionService, "mock", () => {
+  return {
+    callFunction: async (deployedFunctionId, input) => {
+      return input;
+    }
+  };
+});
+_define_property6(RemoteFunctionExecutionService, "mockLayer", Layer6.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock()));
+
+// src/services/service-container.ts
+import { Layer as Layer7 } from "effect";
+import { AiService } from "@dxos/ai";
+import { entries } from "@dxos/util";
+function _define_property7(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+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 {
+  /**
+  * 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);
+  }
+  constructor() {
+    _define_property7(this, "_services", {
+      ...DEFAULT_SERVICES
+    });
+  }
+};
+
+export {
+  FUNCTIONS_META_KEY,
+  FUNCTIONS_PRESET_META_KEY,
+  getUserFunctionIdInMetadata,
+  setUserFunctionIdInMetadata,
+  getInvocationUrl,
+  DatabaseService,
+  QueueService,
+  ContextQueueService,
+  CredentialsService,
+  ConfiguredCredentialsService,
+  withAuthorization,
+  TracingService,
+  MESSAGE_PROPERTY_TOOL_CALL_ID,
+  ComputeEventPayload,
+  ComputeEvent,
+  ComputeEventLogger,
+  logCustomEvent,
+  createDefectLogger,
+  createEventLogger,
+  RemoteFunctionExecutionService,
+  SERVICE_TAGS,
+  ServiceContainer
+};
+//# sourceMappingURL=chunk-MPKVY7ZR.mjs.map