@dxos/functions 0.8.1 → 0.8.2-main.10c050d

package/dist/lib/node/index.cjs

@@ -18,47 +18,60 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  FUNCTIONS_PRESET_META_KEY: () => import_chunk_DSUGRAAL.FUNCTIONS_PRESET_META_KEY,
-  FUNCTION_TYPES: () => import_chunk_DSUGRAAL.FUNCTION_TYPES,
-  FunctionDef: () => import_chunk_DSUGRAAL.FunctionDef,
-  FunctionManifestSchema: () => import_chunk_DSUGRAAL.FunctionManifestSchema,
-  FunctionRegistry: () => import_chunk_RXMCVAMJ.FunctionRegistry,
-  FunctionTrigger: () => import_chunk_DSUGRAAL.FunctionTrigger,
-  FunctionTriggerSchema: () => import_chunk_DSUGRAAL.FunctionTriggerSchema,
-  FunctionType: () => import_chunk_DSUGRAAL.FunctionType,
-  InvocationOutcome: () => import_chunk_DSUGRAAL.InvocationOutcome,
-  InvocationTraceEndEvent: () => import_chunk_DSUGRAAL.InvocationTraceEndEvent,
-  InvocationTraceEventType: () => import_chunk_DSUGRAAL.InvocationTraceEventType,
-  InvocationTraceStartEvent: () => import_chunk_DSUGRAAL.InvocationTraceStartEvent,
-  ScriptType: () => import_chunk_DSUGRAAL.ScriptType,
-  TraceEvent: () => import_chunk_DSUGRAAL.TraceEvent,
-  TraceEventException: () => import_chunk_DSUGRAAL.TraceEventException,
-  TraceEventLog: () => import_chunk_DSUGRAAL.TraceEventLog,
-  TriggerKind: () => import_chunk_DSUGRAAL.TriggerKind,
-  TriggerRegistry: () => import_chunk_RXMCVAMJ.TriggerRegistry,
-  TriggerSchema: () => import_chunk_DSUGRAAL.TriggerSchema,
-  createInvocationSpans: () => import_chunk_DSUGRAAL.createInvocationSpans,
-  createSubscriptionTrigger: () => import_chunk_RXMCVAMJ.createSubscriptionTrigger,
-  createTimerTrigger: () => import_chunk_RXMCVAMJ.createTimerTrigger,
+  AiService: () => AiService,
+  ConfiguredCredentialsService: () => ConfiguredCredentialsService,
+  CredentialsService: () => CredentialsService,
+  DatabaseService: () => DatabaseService,
+  EmailTriggerOutput: () => EmailTriggerOutput,
+  FUNCTIONS_PRESET_META_KEY: () => FUNCTIONS_PRESET_META_KEY,
+  FUNCTION_TYPES: () => FUNCTION_TYPES,
+  FunctionExecutor: () => FunctionExecutor,
+  FunctionManifestSchema: () => FunctionManifestSchema,
+  FunctionTrigger: () => FunctionTrigger,
+  FunctionTriggerSchema: () => FunctionTriggerSchema,
+  FunctionType: () => FunctionType,
+  InvocationOutcome: () => InvocationOutcome,
+  InvocationTraceEndEvent: () => InvocationTraceEndEvent,
+  InvocationTraceEventType: () => InvocationTraceEventType,
+  InvocationTraceStartEvent: () => InvocationTraceStartEvent,
+  QueueTriggerOutput: () => QueueTriggerOutput,
+  QueuesService: () => QueuesService,
+  ScriptType: () => ScriptType,
+  ServiceContainer: () => ServiceContainer,
+  SubscriptionTriggerOutput: () => SubscriptionTriggerOutput,
+  TimerTriggerOutput: () => TimerTriggerOutput,
+  TraceEvent: () => TraceEvent,
+  TraceEventException: () => TraceEventException,
+  TraceEventLog: () => TraceEventLog,
+  TracingService: () => TracingService,
+  TriggerKind: () => TriggerKind,
+  TriggerSchema: () => TriggerSchema,
+  WebhookTriggerOutput: () => WebhookTriggerOutput,
+  createInvocationSpans: () => createInvocationSpans,
   defineFunction: () => defineFunction,
-  getInvocationUrl: () => import_chunk_DSUGRAAL.getInvocationUrl,
-  getUserFunctionUrlInMetadata: () => import_chunk_DSUGRAAL.getUserFunctionUrlInMetadata,
-  incrementSemverPatch: () => import_chunk_NXZNXVT3.incrementSemverPatch,
-  publicKeyToDid: () => import_chunk_NXZNXVT3.publicKeyToDid,
-  setUserFunctionUrlInMetadata: () => import_chunk_DSUGRAAL.setUserFunctionUrlInMetadata,
-  subscriptionHandler: () => subscriptionHandler,
-  uploadWorkerFunction: () => import_chunk_NXZNXVT3.uploadWorkerFunction
+  getInvocationUrl: () => getInvocationUrl,
+  getUserFunctionUrlInMetadata: () => getUserFunctionUrlInMetadata,
+  makeFunctionUrl: () => makeFunctionUrl,
+  setUserFunctionUrlInMetadata: () => setUserFunctionUrlInMetadata
 });
 module.exports = __toCommonJS(node_exports);
-var import_chunk_NXZNXVT3 = require("./chunk-NXZNXVT3.cjs");
-var import_chunk_RXMCVAMJ = require("./chunk-RXMCVAMJ.cjs");
-var import_chunk_DSUGRAAL = require("./chunk-DSUGRAAL.cjs");
-var import_chunk_JEQ2X3Z6 = require("./chunk-JEQ2X3Z6.cjs");
 var import_effect = require("effect");
-var import_client = require("@dxos/client");
+var import_effect2 = require("effect");
+var import_echo_schema = require("@dxos/echo-schema");
+var import_schema = require("@dxos/schema");
+var import_effect3 = require("effect");
+var import_echo_db = require("@dxos/echo-db");
+var import_echo_schema2 = require("@dxos/echo-schema");
 var import_log = require("@dxos/log");
-var import_util = require("@dxos/util");
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/handler.ts";
+var import_effect4 = require("effect");
+var import_echo_schema3 = require("@dxos/echo-schema");
+var import_keys = require("@dxos/keys");
+var import_effect5 = require("effect");
+var import_effect6 = require("effect");
+var import_effect7 = require("effect");
+var import_effect8 = require("effect");
+var import_effect9 = require("effect");
+var import_effect10 = require("effect");
 var defineFunction = (params) => {
   if (!import_effect.Schema.isSchema(params.inputSchema)) {
     throw new Error("Input schema must be a valid schema");
@@ -73,72 +86,485 @@ var defineFunction = (params) => {
     handler: params.handler
   };
 };
-var subscriptionHandler = (handler, types) => {
-  return async ({ event: { data }, context, response, ...rest }) => {
-    const { client } = context;
-    const space = data.spaceKey ? client.spaces.get(import_client.PublicKey.from(data.spaceKey)) : void 0;
-    if (!space) {
-      import_log.log.error("Invalid space", void 0, {
-        F: __dxlog_file,
-        L: 180,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      return response.status(500);
+var ScriptType = import_effect2.Schema.Struct({
+  name: import_effect2.Schema.optional(import_effect2.Schema.String),
+  description: import_effect2.Schema.optional(import_effect2.Schema.String),
+  // TODO(burdon): Change to hash of deployed content.
+  // Whether source has changed since last deploy.
+  changed: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
+  source: (0, import_echo_schema.Ref)(import_schema.DataType.Text)
+}).pipe((0, import_echo_schema.EchoObject)({
+  typename: "dxos.org/type/Script",
+  version: "0.1.0"
+}), import_echo_schema.LabelAnnotation.set([
+  "name"
+]));
+var FunctionType = class extends (0, import_echo_schema.TypedObject)({
+  typename: "dxos.org/type/Function",
+  version: "0.1.0"
+})({
+  // TODO(burdon): Rename to id/uri?
+  name: import_effect2.Schema.NonEmptyString,
+  version: import_effect2.Schema.String,
+  description: import_effect2.Schema.optional(import_effect2.Schema.String),
+  // Reference to a source script if it exists within ECHO.
+  // TODO(burdon): Don't ref ScriptType directly (core).
+  source: import_effect2.Schema.optional((0, import_echo_schema.Ref)(ScriptType)),
+  inputSchema: import_effect2.Schema.optional(import_echo_schema.JsonSchemaType),
+  outputSchema: import_effect2.Schema.optional(import_echo_schema.JsonSchemaType),
+  // Local binding to a function name.
+  binding: import_effect2.Schema.optional(import_effect2.Schema.String)
+}) {
+};
+var TriggerKind = /* @__PURE__ */ function(TriggerKind2) {
+  TriggerKind2["Timer"] = "timer";
+  TriggerKind2["Webhook"] = "webhook";
+  TriggerKind2["Subscription"] = "subscription";
+  TriggerKind2["Email"] = "email";
+  TriggerKind2["Queue"] = "queue";
+  return TriggerKind2;
+}({});
+var kindLiteralAnnotations = {
+  title: "Kind"
+};
+var TimerTriggerSchema = import_effect4.Schema.Struct({
+  kind: import_effect4.Schema.Literal("timer").annotations(kindLiteralAnnotations),
+  cron: import_effect4.Schema.String.annotations({
+    title: "Cron",
+    [import_effect4.SchemaAST.ExamplesAnnotationId]: [
+      "0 0 * * *"
+    ]
+  })
+}).pipe(import_effect4.Schema.mutable);
+var EmailTriggerSchema = import_effect4.Schema.Struct({
+  kind: import_effect4.Schema.Literal("email").annotations(kindLiteralAnnotations)
+}).pipe(import_effect4.Schema.mutable);
+var QueueTriggerSchema = import_effect4.Schema.Struct({
+  kind: import_effect4.Schema.Literal("queue").annotations(kindLiteralAnnotations),
+  queue: import_keys.DXN.Schema
+}).pipe(import_effect4.Schema.mutable);
+var WebhookTriggerSchema = import_effect4.Schema.Struct({
+  kind: import_effect4.Schema.Literal("webhook").annotations(kindLiteralAnnotations),
+  method: import_effect4.Schema.optional(import_effect4.Schema.String.annotations({
+    title: "Method",
+    [import_echo_schema3.OptionsAnnotationId]: [
+      "GET",
+      "POST"
+    ]
+  })),
+  port: import_effect4.Schema.optional(import_effect4.Schema.Number.annotations({
+    title: "Port"
+  }))
+}).pipe(import_effect4.Schema.mutable);
+var QuerySchema = import_effect4.Schema.Struct({
+  type: import_effect4.Schema.optional(import_effect4.Schema.String.annotations({
+    title: "Type"
+  })),
+  props: import_effect4.Schema.optional(import_effect4.Schema.Record({
+    key: import_effect4.Schema.String,
+    value: import_effect4.Schema.Any
+  }))
+}).annotations({
+  title: "Query"
+});
+var SubscriptionTriggerSchema = import_effect4.Schema.Struct({
+  kind: import_effect4.Schema.Literal("subscription").annotations(kindLiteralAnnotations),
+  // TODO(burdon): Define query DSL (from ECHO). Reconcile with Table.Query.
+  filter: QuerySchema,
+  options: import_effect4.Schema.optional(import_effect4.Schema.Struct({
+    // Watch changes to object (not just creation).
+    deep: import_effect4.Schema.optional(import_effect4.Schema.Boolean.annotations({
+      title: "Nested"
+    })),
+    // Debounce changes (delay in ms).
+    delay: import_effect4.Schema.optional(import_effect4.Schema.Number.annotations({
+      title: "Delay"
+    }))
+  }).annotations({
+    title: "Options"
+  }))
+}).pipe(import_effect4.Schema.mutable);
+var TriggerSchema = import_effect4.Schema.Union(TimerTriggerSchema, WebhookTriggerSchema, SubscriptionTriggerSchema, EmailTriggerSchema, QueueTriggerSchema).annotations({
+  title: "Trigger"
+});
+var EmailTriggerOutput = import_effect4.Schema.mutable(import_effect4.Schema.Struct({
+  from: import_effect4.Schema.String,
+  to: import_effect4.Schema.String,
+  subject: import_effect4.Schema.String,
+  created: import_effect4.Schema.String,
+  body: import_effect4.Schema.String
+}));
+var WebhookTriggerOutput = import_effect4.Schema.mutable(import_effect4.Schema.Struct({
+  url: import_effect4.Schema.String,
+  method: import_effect4.Schema.Literal("GET", "POST"),
+  headers: import_effect4.Schema.Record({
+    key: import_effect4.Schema.String,
+    value: import_effect4.Schema.String
+  }),
+  bodyText: import_effect4.Schema.String
+}));
+var QueueTriggerOutput = import_effect4.Schema.mutable(import_effect4.Schema.Struct({
+  queue: import_keys.DXN.Schema,
+  item: import_effect4.Schema.Any,
+  cursor: import_effect4.Schema.String
+}));
+var SubscriptionTriggerOutput = import_effect4.Schema.mutable(import_effect4.Schema.Struct({
+  type: import_effect4.Schema.String,
+  changedObjectId: import_effect4.Schema.String
+}));
+var TimerTriggerOutput = import_effect4.Schema.mutable(import_effect4.Schema.Struct({
+  tick: import_effect4.Schema.Number
+}));
+var FunctionTriggerSchema = import_effect4.Schema.Struct({
+  /**
+  * Function or workflow to invoke.
+  */
+  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
+  function: import_effect4.Schema.optional((0, import_echo_schema3.Ref)(import_echo_schema3.Expando).annotations({
+    title: "Function"
+  })),
+  /**
+  * Only used for workflowSchema.
+  * Specifies the input node in the circuit.
+  * @deprecated Remove and enforce a single input node in all compute graphSchema.
+  */
+  inputNodeId: import_effect4.Schema.optional(import_effect4.Schema.String.annotations({
+    title: "Input Node ID"
+  })),
+  enabled: import_effect4.Schema.optional(import_effect4.Schema.Boolean.annotations({
+    title: "Enabled"
+  })),
+  spec: import_effect4.Schema.optional(TriggerSchema),
+  /**
+  * Passed as the input data to the function.
+  * Must match the function's input schema.
+  *
+  * @example
+  * {
+  *   item: '{{$.trigger.event}}',
+  *   instructions: 'Summarize and perform entity-extraction'
+  *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
+  * }
+  */
+  input: import_effect4.Schema.optional(import_effect4.Schema.mutable(import_effect4.Schema.Record({
+    key: import_effect4.Schema.String,
+    value: import_effect4.Schema.Any
+  })))
+});
+var FunctionTrigger = class extends (0, import_echo_schema3.TypedObject)({
+  typename: "dxos.org/type/FunctionTrigger",
+  version: "0.2.0"
+})(FunctionTriggerSchema.fields) {
+};
+var FunctionManifestSchema = import_effect4.Schema.Struct({
+  functions: import_effect4.Schema.optional(import_effect4.Schema.mutable(import_effect4.Schema.Array((0, import_echo_schema3.RawObject)(FunctionType)))),
+  triggers: import_effect4.Schema.optional(import_effect4.Schema.mutable(import_effect4.Schema.Array((0, import_echo_schema3.RawObject)(FunctionTrigger))))
+});
+var FUNCTION_TYPES = [
+  FunctionType,
+  FunctionTrigger
+];
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/trace.ts";
+var InvocationOutcome = /* @__PURE__ */ function(InvocationOutcome2) {
+  InvocationOutcome2["SUCCESS"] = "success";
+  InvocationOutcome2["FAILURE"] = "failure";
+  InvocationOutcome2["PENDING"] = "pending";
+  return InvocationOutcome2;
+}({});
+var InvocationTraceEventType = /* @__PURE__ */ function(InvocationTraceEventType2) {
+  InvocationTraceEventType2["START"] = "start";
+  InvocationTraceEventType2["END"] = "end";
+  return InvocationTraceEventType2;
+}({});
+var TraceEventException = import_effect3.Schema.Struct({
+  timestampMs: import_effect3.Schema.Number,
+  message: import_effect3.Schema.String,
+  name: import_effect3.Schema.String,
+  stack: import_effect3.Schema.optional(import_effect3.Schema.String)
+});
+var InvocationTraceStartEvent = import_effect3.Schema.Struct({
+  /**
+  * Queue message id.
+  */
+  id: import_echo_schema2.ObjectId,
+  type: import_effect3.Schema.Literal("start"),
+  /**
+  * Invocation id, the same for invocation start and end events.
+  */
+  invocationId: import_echo_schema2.ObjectId,
+  /**
+  * Event generation time.
+  */
+  timestampMs: import_effect3.Schema.Number,
+  /**
+  * Data passed to function / workflow as an argument.
+  */
+  // TODO(burdon): Input schema?
+  input: import_effect3.Schema.Object,
+  /**
+  * Queue  for function/workflow invocation events.
+  */
+  invocationTraceQueue: (0, import_echo_schema2.Ref)(import_echo_db.Queue),
+  /**
+  * DXN of the invoked function/workflow.
+  */
+  invocationTarget: (0, import_echo_schema2.Ref)(import_echo_schema2.Expando),
+  /**
+  * Present for automatic invocations.
+  */
+  trigger: import_effect3.Schema.optional((0, import_echo_schema2.Ref)(FunctionTrigger))
+}).pipe((0, import_echo_schema2.EchoObject)({
+  typename: "dxos.org/type/InvocationTraceStart",
+  version: "0.1.0"
+}));
+var InvocationTraceEndEvent = import_effect3.Schema.Struct({
+  /**
+  * Trace event id.
+  */
+  id: import_echo_schema2.ObjectId,
+  type: import_effect3.Schema.Literal("end"),
+  /**
+  * Invocation id, will be the same for invocation start and end.
+  */
+  invocationId: import_echo_schema2.ObjectId,
+  /**
+  * Event generation time.
+  */
+  // TODO(burdon): Remove ms suffix.
+  timestampMs: import_effect3.Schema.Number,
+  outcome: import_effect3.Schema.Enums(InvocationOutcome),
+  exception: import_effect3.Schema.optional(TraceEventException)
+}).pipe((0, import_echo_schema2.EchoObject)({
+  typename: "dxos.org/type/InvocationTraceEnd",
+  version: "0.1.0"
+}));
+var TraceEventLog = import_effect3.Schema.Struct({
+  timestampMs: import_effect3.Schema.Number,
+  level: import_effect3.Schema.String,
+  message: import_effect3.Schema.String,
+  context: import_effect3.Schema.optional(import_effect3.Schema.Object)
+});
+var TraceEvent = import_effect3.Schema.Struct({
+  id: import_echo_schema2.ObjectId,
+  // TODO(burdon): Need enum/numeric result (not string).
+  outcome: import_effect3.Schema.String,
+  truncated: import_effect3.Schema.Boolean,
+  /**
+  * Time when the event was persisted.
+  */
+  ingestionTimestampMs: import_effect3.Schema.Number,
+  logs: import_effect3.Schema.Array(TraceEventLog),
+  exceptions: import_effect3.Schema.Array(TraceEventException)
+}).pipe((0, import_echo_schema2.EchoObject)({
+  typename: "dxos.org/type/TraceEvent",
+  version: "0.1.0"
+}));
+var createInvocationSpans = (items) => {
+  if (!items) {
+    return [];
+  }
+  const eventsByInvocationId = /* @__PURE__ */ new Map();
+  for (const event of items) {
+    if (!("invocationId" in event)) {
+      continue;
     }
-    registerTypes(space, types);
-    const objects = space ? data.objects?.map((id) => space.db.getObjectById(id)).filter(import_util.isNonNullable) : [];
-    if (!!data.spaceKey && !space) {
-      import_log.log.warn("invalid space", {
-        data
-      }, {
-        F: __dxlog_file,
-        L: 192,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-    } else {
-      import_log.log.info("handler", {
-        space: space?.key.truncate(),
-        objects: objects?.length
+    const invocationId = event.invocationId;
+    const entry = eventsByInvocationId.get(invocationId) || {
+      start: void 0,
+      end: void 0
+    };
+    if (event.type === "start") {
+      entry.start = event;
+    } else if (event.type === "end") {
+      entry.end = event;
+    }
+    eventsByInvocationId.set(invocationId, entry);
+  }
+  const now = Date.now();
+  const result = [];
+  for (const [invocationId, { start, end }] of eventsByInvocationId.entries()) {
+    if (!start) {
+      import_log.log.warn("found end event without matching start", {
+        invocationId
       }, {
         F: __dxlog_file,
-        L: 194,
+        L: 160,
         S: void 0,
         C: (f, a) => f(...a)
       });
+      continue;
     }
-    return handler({
-      event: {
-        data: {
-          ...data,
-          space,
-          objects
-        }
+    const isInProgress = end === void 0;
+    result.push({
+      id: invocationId,
+      timestampMs: start.timestampMs,
+      durationMs: isInProgress ? now - start.timestampMs : end.timestampMs - start.timestampMs,
+      outcome: end?.outcome ?? "pending",
+      exception: end?.exception,
+      input: start.input,
+      invocationTraceQueue: start.invocationTraceQueue,
+      invocationTarget: start.invocationTarget,
+      trigger: start.trigger
+    });
+  }
+  return result;
+};
+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 getUserFunctionUrlInMetadata = (meta) => {
+  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
+};
+var setUserFunctionUrlInMetadata = (meta, functionUrl) => {
+  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionUrl) {
+      throw new Error("Metadata mismatch");
+    }
+  } else {
+    meta.keys.push({
+      source: FUNCTIONS_META_KEY,
+      id: functionUrl
+    });
+  }
+};
+var makeFunctionUrl = (fn) => `/${fn.functionId}`;
+var getInvocationUrl = (functionUrl, edgeUrl, options = {}) => {
+  const baseUrl = new URL("functions/", edgeUrl);
+  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();
+};
+var AiService = class extends import_effect5.Context.Tag("AiService")() {
+};
+var DatabaseService = class extends import_effect6.Context.Tag("DatabaseService")() {
+};
+var QueuesService = class extends import_effect7.Context.Tag("QueuesService")() {
+};
+var CredentialsService = class extends import_effect8.Context.Tag("CredentialsService")() {
+};
+var ConfiguredCredentialsService = class {
+  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 TracingService = class extends import_effect9.Context.Tag("TracingService")() {
+  static {
+    this.noop = {
+      write: () => {
+      }
+    };
+  }
+  static {
+    this.console = {
+      write: (event) => {
+        console.log(event);
+      }
+    };
+  }
+};
+var SERVICE_MAPPING = {
+  [DatabaseService.key]: "database",
+  [AiService.key]: "ai",
+  [QueuesService.key]: "queues",
+  [CredentialsService.key]: "credentials",
+  [TracingService.key]: "tracing"
+};
+var DEFAULT_SERVICES = {
+  tracing: TracingService.noop
+};
+var ServiceContainer = class _ServiceContainer {
+  constructor() {
+    this._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
+    });
+  }
+};
+var FunctionExecutor = class {
+  constructor(_services) {
+    this._services = _services;
+  }
+  // TODO(dmaretskyi): Invocation context: queue, space, etc...
+  async invoke(fnDef, input) {
+    const assertInput = fnDef.inputSchema.pipe(import_effect10.Schema.asserts);
+    assertInput(input);
+    const context = {
+      getService: this._services.getService.bind(this._services),
+      getSpace: async (_spaceId) => {
+        throw new Error("Not available. Use the database service instead.");
       },
+      space: void 0,
+      get ai() {
+        throw new Error("Not available. Use the ai service instead.");
+      }
+    };
+    const result = await fnDef.handler({
       context,
-      response,
-      ...rest
+      data: input
     });
-  };
-};
-var registerTypes = (space, types = []) => {
-  const registry = space.db.graph.schemaRegistry;
-  for (const type of types) {
-    if (!registry.hasSchema(type)) {
-      registry.addSchema([
-        type
-      ]);
+    const assertOutput = fnDef.outputSchema?.pipe(import_effect10.Schema.asserts);
+    assertOutput(result);
+    if (import_effect10.Effect.isEffect(result)) {
+      return import_effect10.Effect.runPromise(result);
     }
+    return result;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AiService,
+  ConfiguredCredentialsService,
+  CredentialsService,
+  DatabaseService,
+  EmailTriggerOutput,
   FUNCTIONS_PRESET_META_KEY,
   FUNCTION_TYPES,
-  FunctionDef,
+  FunctionExecutor,
   FunctionManifestSchema,
-  FunctionRegistry,
   FunctionTrigger,
   FunctionTriggerSchema,
   FunctionType,
@@ -146,23 +572,24 @@ var registerTypes = (space, types = []) => {
   InvocationTraceEndEvent,
   InvocationTraceEventType,
   InvocationTraceStartEvent,
+  QueueTriggerOutput,
+  QueuesService,
   ScriptType,
+  ServiceContainer,
+  SubscriptionTriggerOutput,
+  TimerTriggerOutput,
   TraceEvent,
   TraceEventException,
   TraceEventLog,
+  TracingService,
   TriggerKind,
-  TriggerRegistry,
   TriggerSchema,
+  WebhookTriggerOutput,
   createInvocationSpans,
-  createSubscriptionTrigger,
-  createTimerTrigger,
   defineFunction,
   getInvocationUrl,
   getUserFunctionUrlInMetadata,
-  incrementSemverPatch,
-  publicKeyToDid,
-  setUserFunctionUrlInMetadata,
-  subscriptionHandler,
-  uploadWorkerFunction
+  makeFunctionUrl,
+  setUserFunctionUrlInMetadata
 });
 //# sourceMappingURL=index.cjs.map