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

package/dist/lib/node-esm/index.mjs

@@ -1,55 +1,58 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  ComputeEvent,
-  ComputeEventLogger,
-  ComputeEventPayload,
-  ConfiguredCredentialsService,
-  ContextQueueService,
-  CredentialsService,
-  DatabaseService,
-  FUNCTIONS_META_KEY,
-  FUNCTIONS_PRESET_META_KEY,
-  FunctionError,
-  FunctionNotFoundError,
-  MESSAGE_PROPERTY_TOOL_CALL_ID,
-  QueueService,
-  RemoteFunctionExecutionService,
-  SERVICE_TAGS,
-  ServiceContainer,
-  ServiceNotAvailableError,
-  TracingService,
-  TriggerStateNotFoundError,
-  createDefectLogger,
-  createEventLogger,
-  getInvocationUrl,
-  getUserFunctionIdInMetadata,
-  logCustomEvent,
-  setUserFunctionIdInMetadata,
-  withAuthorization
-} from "./chunk-P3IATZMZ.mjs";
-import {
-  __export
-} from "./chunk-HSLMI22Q.mjs";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var ServiceNotAvailableError = class extends BaseError.extend("ServiceNotAvailable", "Service not available") {
+  constructor(service, options) {
+    super({
+      context: {
+        service
+      },
+      ...options
+    });
+  }
+};
+var FunctionNotFoundError = class extends BaseError.extend("FunctionNotFound", "Function not found") {
+  constructor(functionKey, options) {
+    super({
+      context: {
+        function: functionKey
+      },
+      ...options
+    });
+  }
+};
+var FunctionError = class extends BaseError.extend("FunctionError", "Function invocation error") {
+};
+var TriggerStateNotFoundError = class extends BaseError.extend("TriggerStateNotFound", "Trigger state not found") {
+};
 
 // src/example/fib.ts
 import * as Effect2 from "effect/Effect";
 import * as Schema6 from "effect/Schema";
 
-// src/handler.ts
+// src/sdk.ts
 import * as Effect from "effect/Effect";
 import * as Schema5 from "effect/Schema";
-import { Obj as Obj5, Type as Type5 } from "@dxos/echo";
-import { assertArgument } from "@dxos/invariant";
+import { Obj as Obj4, Type as Type5 } from "@dxos/echo";
+import { assertArgument, failedInvariant } from "@dxos/invariant";
+import { Operation } from "@dxos/operation";
 
 // src/types/Function.ts
 var Function_exports = {};
 __export(Function_exports, {
   Function: () => Function,
-  make: () => make2
+  make: () => make2,
+  setFrom: () => setFrom
 });
 import * as Schema2 from "effect/Schema";
-import { Obj as Obj2, Type as Type2 } from "@dxos/echo";
-import { JsonSchemaType, LabelAnnotation as LabelAnnotation2, Ref as Ref2 } from "@dxos/echo/internal";
+import { Annotation as Annotation2, JsonSchema, Obj as Obj2, Type as Type2 } from "@dxos/echo";
+import { SystemTypeAnnotation } from "@dxos/echo/internal";
 
 // src/types/Script.ts
 var Script_exports = {};
@@ -58,25 +61,25 @@ __export(Script_exports, {
   make: () => make
 });
 import * as Schema from "effect/Schema";
-import { Obj, Ref, Type } from "@dxos/echo";
-import { FormAnnotation, LabelAnnotation } from "@dxos/echo/internal";
-import { DataType } from "@dxos/schema";
+import { Annotation, Obj, Ref, Type } from "@dxos/echo";
+import { FormInputAnnotation } from "@dxos/echo/internal";
+import { Text } from "@dxos/schema";
 var Script = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
   description: Schema.String.pipe(Schema.optional),
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
-  changed: Schema.Boolean.pipe(FormAnnotation.set(false), Schema.optional),
-  source: Type.Ref(DataType.Text).pipe(FormAnnotation.set(false))
-}).pipe(Type.Obj({
+  changed: Schema.Boolean.pipe(FormInputAnnotation.set(false), Schema.optional),
+  source: Type.Ref(Text.Text).pipe(FormInputAnnotation.set(false))
+}).pipe(Type.object({
   typename: "dxos.org/type/Script",
   version: "0.1.0"
-}), LabelAnnotation.set([
+}), Annotation.LabelAnnotation.set([
   "name"
 ]));
 var make = ({ source = "", ...props } = {}) => Obj.make(Script, {
   ...props,
-  source: Ref.make(DataType.makeText(source))
+  source: Ref.make(Text.make(source))
 });
 
 // src/types/Function.ts
@@ -91,24 +94,44 @@ var Function = Schema2.Struct({
   key: Schema2.optional(Schema2.String).annotations({
     description: "Unique registration key for the blueprint"
   }),
-  // TODO(burdon): Rename to id/uri?
   name: Schema2.NonEmptyString,
   version: Schema2.String,
   description: Schema2.optional(Schema2.String),
+  /**
+  * ISO date string of the last deployment.
+  */
+  updated: Schema2.optional(Schema2.String),
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema2.optional(Ref2(Script)),
-  inputSchema: Schema2.optional(JsonSchemaType),
-  outputSchema: Schema2.optional(JsonSchemaType),
+  source: Schema2.optional(Type2.Ref(Script)),
+  inputSchema: Schema2.optional(JsonSchema.JsonSchema),
+  outputSchema: Schema2.optional(JsonSchema.JsonSchema),
+  /**
+  * List of required services.
+  * Match the Context.Tag keys of the FunctionServices variants.
+  */
+  services: Schema2.optional(Schema2.Array(Schema2.String)),
   // Local binding to a function name.
   binding: Schema2.optional(Schema2.String)
-}).pipe(Type2.Obj({
+}).pipe(Type2.object({
   typename: "dxos.org/type/Function",
   version: "0.1.0"
-}), LabelAnnotation2.set([
+}), Annotation2.LabelAnnotation.set([
   "name"
-]));
+]), SystemTypeAnnotation.set(true));
 var make2 = (props) => Obj2.make(Function, props);
+var setFrom = (target, source) => {
+  Obj2.change(target, (t) => {
+    t.key = source.key ?? target.key;
+    t.name = source.name ?? target.name;
+    t.version = source.version;
+    t.description = source.description;
+    t.updated = source.updated;
+    t.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : void 0;
+    t.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : void 0;
+    Obj2.getMeta(t).keys = JSON.parse(JSON.stringify(Obj2.getMeta(source).keys));
+  });
+};
 
 // src/types/Trigger.ts
 var Trigger_exports = {};
@@ -126,8 +149,9 @@ __export(Trigger_exports, {
 import * as Schema3 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 import { Obj as Obj3, QueryAST, Type as Type3 } from "@dxos/echo";
-import { Expando, OptionsAnnotationId, Ref as Ref3 } from "@dxos/echo/internal";
+import { OptionsAnnotationId, SystemTypeAnnotation as SystemTypeAnnotation2 } from "@dxos/echo/internal";
 import { DXN } from "@dxos/keys";
+import { Expando } from "@dxos/schema";
 var Kinds = [
   "email",
   "queue",
@@ -140,12 +164,12 @@ var kindLiteralAnnotations = {
 };
 var EmailSpec = Schema3.Struct({
   kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
-}).pipe(Schema3.mutable);
+});
 var QueueSpec = Schema3.Struct({
   kind: Schema3.Literal("queue").annotations(kindLiteralAnnotations),
   // TODO(dmaretskyi): Change to a reference.
   queue: DXN.Schema
-}).pipe(Schema3.mutable);
+});
 var SubscriptionSpec = Schema3.Struct({
   kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
   query: Schema3.Struct({
@@ -153,7 +177,7 @@ var SubscriptionSpec = Schema3.Struct({
       title: "Query"
     })),
     ast: QueryAST.Query
-  }).pipe(Schema3.mutable),
+  }),
   options: Schema3.optional(Schema3.Struct({
     // Watch changes to object (not just creation).
     deep: Schema3.optional(Schema3.Boolean.annotations({
@@ -166,7 +190,7 @@ var SubscriptionSpec = Schema3.Struct({
   }).annotations({
     title: "Options"
   }))
-}).pipe(Schema3.mutable);
+});
 var TimerSpec = Schema3.Struct({
   kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
   cron: Schema3.String.annotations({
@@ -175,7 +199,7 @@ var TimerSpec = Schema3.Struct({
       "0 0 * * *"
     ]
   })
-}).pipe(Schema3.mutable);
+});
 var WebhookSpec = Schema3.Struct({
   kind: Schema3.Literal("webhook").annotations(kindLiteralAnnotations),
   method: Schema3.optional(Schema3.String.annotations({
@@ -188,16 +212,16 @@ var WebhookSpec = Schema3.Struct({
   port: Schema3.optional(Schema3.Number.annotations({
     title: "Port"
   }))
-}).pipe(Schema3.mutable);
+});
 var Spec = Schema3.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
   title: "Trigger"
 });
-var Trigger_ = Schema3.Struct({
+var TriggerSchema = Schema3.Struct({
   /**
   * Function or workflow to invoke.
   */
   // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema3.optional(Ref3(Expando).annotations({
+  function: Schema3.optional(Type3.Ref(Expando.Expando).annotations({
     title: "Function"
   })),
   /**
@@ -208,6 +232,8 @@ var Trigger_ = Schema3.Struct({
   inputNodeId: Schema3.optional(Schema3.String.annotations({
     title: "Input Node ID"
   })),
+  // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
+  //  Need lint rule; or agent rule to require PR review for "boolean" key word.
   enabled: Schema3.optional(Schema3.Boolean.annotations({
     title: "Enabled"
   })),
@@ -223,15 +249,15 @@ var Trigger_ = Schema3.Struct({
   *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
   * }
   */
-  input: Schema3.optional(Schema3.mutable(Schema3.Record({
+  input: Schema3.optional(Schema3.Record({
     key: Schema3.String,
     value: Schema3.Any
-  })))
-}).pipe(Type3.Obj({
+  }))
+}).pipe(Type3.object({
   typename: "dxos.org/type/Trigger",
   version: "0.1.0"
-}));
-var Trigger = Trigger_;
+}), SystemTypeAnnotation2.set(true));
+var Trigger = TriggerSchema;
 var make3 = (props) => Obj3.make(Trigger, props);
 
 // src/types/TriggerEvent.ts
@@ -241,22 +267,23 @@ __export(TriggerEvent_exports, {
   QueueEvent: () => QueueEvent,
   SubscriptionEvent: () => SubscriptionEvent,
   TimerEvent: () => TimerEvent,
+  TriggerEvent: () => TriggerEvent,
   WebhookEvent: () => WebhookEvent
 });
 import * as Schema4 from "effect/Schema";
-import { DXN as DXN2, Obj as Obj4, Type as Type4 } from "@dxos/echo";
-var EmailEvent = Schema4.mutable(Schema4.Struct({
+import { DXN as DXN2, Type as Type4 } from "@dxos/echo";
+var EmailEvent = Schema4.Struct({
   from: Schema4.String,
   to: Schema4.String,
   subject: Schema4.String,
   created: Schema4.String,
   body: Schema4.String
-}));
-var QueueEvent = Schema4.mutable(Schema4.Struct({
+});
+var QueueEvent = Schema4.Struct({
   queue: DXN2.Schema,
   item: Schema4.Any,
   cursor: Schema4.String
-}));
+});
 var SubscriptionEvent = Schema4.Struct({
   /**
   * Type of the mutation.
@@ -266,16 +293,16 @@ var SubscriptionEvent = Schema4.Struct({
   /**
   * Reference to the object that was changed or created.
   */
-  subject: Type4.Ref(Obj4.Any),
+  subject: Type4.Ref(Type4.Obj),
   /**
   * @deprecated
   */
   changedObjectId: Schema4.optional(Schema4.String)
-}).pipe(Schema4.mutable);
-var TimerEvent = Schema4.mutable(Schema4.Struct({
+});
+var TimerEvent = Schema4.Struct({
   tick: Schema4.Number
-}));
-var WebhookEvent = Schema4.mutable(Schema4.Struct({
+});
+var WebhookEvent = Schema4.Struct({
   url: Schema4.String,
   method: Schema4.Literal("GET", "POST"),
   headers: Schema4.Record({
@@ -283,11 +310,32 @@ var WebhookEvent = Schema4.mutable(Schema4.Struct({
     value: Schema4.String
   }),
   bodyText: Schema4.String
-}));
+});
+var TriggerEvent = Schema4.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
 
-// src/handler.ts
+// src/types/url.ts
+var FUNCTIONS_META_KEY = "dxos.org/service/function";
+var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
+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
+    });
+  }
+};
+
+// src/sdk.ts
 var typeId = Symbol.for("@dxos/functions/FunctionDefinition");
-var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler }) => {
+var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler, types, services }) => {
   if (!Schema5.isSchema(inputSchema)) {
     throw new Error("Input schema must be a valid schema");
   }
@@ -327,36 +375,78 @@ var defineFunction = ({ key, name, description, inputSchema, outputSchema = Sche
     description,
     inputSchema,
     outputSchema,
-    handler: handlerWithSpan
+    handler: handlerWithSpan,
+    types: types ?? [],
+    services: !services ? [] : getServiceKeys(services)
+  };
+};
+var getServiceKeys = (services) => {
+  return services.map((tag) => {
+    if (typeof tag.key === "string") {
+      return tag.key;
+    }
+    failedInvariant();
+  });
+};
+var toOperation = (functionDef) => {
+  const op = Operation.make({
+    schema: {
+      input: functionDef.inputSchema,
+      output: functionDef.outputSchema ?? Schema5.Any
+    },
+    meta: {
+      key: functionDef.key,
+      name: functionDef.name,
+      description: functionDef.description
+    }
+  });
+  const operationHandler = (input) => {
+    const result = functionDef.handler({
+      context: {},
+      data: input
+    });
+    if (Effect.isEffect(result)) {
+      return result;
+    }
+    if (result instanceof Promise) {
+      return Effect.tryPromise(() => result);
+    }
+    return Effect.succeed(result);
+  };
+  return {
+    ...op,
+    handler: operationHandler
   };
 };
 var FunctionDefinition = {
   make: defineFunction,
-  isFunction: (value) => {
-    return typeof value === "object" && value !== null && Symbol.for("@dxos/functions/FunctionDefinition") in value;
+  isFunction: (value2) => {
+    return typeof value2 === "object" && value2 !== null && Symbol.for("@dxos/functions/FunctionDefinition") in value2;
   },
   serialize: (functionDef) => {
     assertArgument(FunctionDefinition.isFunction(functionDef), "functionDef");
     return serializeFunction(functionDef);
   },
   deserialize: (functionObj) => {
-    assertArgument(Obj5.instanceOf(Function_exports.Function, functionObj), "functionObj");
+    assertArgument(Obj4.instanceOf(Function_exports.Function, functionObj), "functionObj");
     return deserializeFunction(functionObj);
-  }
+  },
+  toOperation
 };
 var serializeFunction = (functionDef) => {
-  const fn6 = Function_exports.make({
+  const fn4 = Function_exports.make({
     key: functionDef.key,
     name: functionDef.name,
     version: "0.1.0",
     description: functionDef.description,
     inputSchema: Type5.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? void 0 : Type5.toJsonSchema(functionDef.outputSchema)
+    outputSchema: !functionDef.outputSchema ? void 0 : Type5.toJsonSchema(functionDef.outputSchema),
+    services: functionDef.services
   });
   if (functionDef.meta?.deployedFunctionId) {
-    setUserFunctionIdInMetadata(Obj5.getMeta(fn6), functionDef.meta.deployedFunctionId);
+    Obj4.change(fn4, (fn5) => setUserFunctionIdInMetadata(Obj4.getMeta(fn5), functionDef.meta.deployedFunctionId));
   }
-  return fn6;
+  return fn4;
 };
 var deserializeFunction = (functionObj) => {
   return {
@@ -370,8 +460,10 @@ var deserializeFunction = (functionObj) => {
     // TODO(dmaretskyi): This should throw error.
     handler: () => {
     },
+    services: functionObj.services ?? [],
+    types: [],
     meta: {
-      deployedFunctionId: getUserFunctionIdInMetadata(Obj5.getMeta(functionObj))
+      deployedFunctionId: getUserFunctionIdInMetadata(Obj4.getMeta(functionObj))
     }
   };
 };
@@ -448,849 +540,658 @@ var sleep_default = defineFunction({
 })(Example || (Example = {}));
 var Example;
 
-// src/executor/executor.ts
+// src/services/credentials.ts
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Context from "effect/Context";
 import * as Effect5 from "effect/Effect";
-import * as Schema9 from "effect/Schema";
-import { runAndForwardErrors } from "@dxos/effect";
-var FunctionExecutor = class {
-  _services;
-  constructor(_services) {
-    this._services = _services;
-  }
-  /**
-  * Invoke function.
-  */
-  // TODO(dmaretskyi): Invocation context: queue, space, etc...
-  async invoke(functionDef, input) {
-    const assertInput = functionDef.inputSchema.pipe(Schema9.asserts);
-    assertInput(input);
-    const context = {
-      space: void 0,
-      getService: this._services.getService.bind(this._services),
-      getSpace: async (_spaceId) => {
-        throw new Error("Not available. Use the database service instead.");
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { Query } from "@dxos/echo";
+import { Database } from "@dxos/echo";
+import { AccessToken } from "@dxos/types";
+var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/functions/CredentialsService")() {
+  static getCredential = (query) => Effect5.gen(function* () {
+    const credentials = yield* _CredentialsService;
+    return yield* Effect5.promise(() => credentials.getCredential(query));
+  });
+  static getApiKey = (query) => Effect5.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) => Layer.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
+  static layerConfig = (credentials) => Layer.effect(_CredentialsService, Effect5.gen(function* () {
+    const serviceCredentials = yield* Effect5.forEach(credentials, ({ service, apiKey }) => Effect5.gen(function* () {
+      return {
+        service,
+        apiKey: Redacted.value(yield* apiKey)
+      };
+    }));
+    return new ConfiguredCredentialsService(serviceCredentials);
+  }));
+  static layerFromDatabase = ({ caching = false } = {}) => Layer.effect(_CredentialsService, Effect5.gen(function* () {
+    const dbService = yield* Database.Service;
+    const cache = /* @__PURE__ */ new Map();
+    const queryCredentials = async (query) => {
+      const cacheKey = JSON.stringify(query);
+      if (caching && cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+      }
+      const accessTokens = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
+      const credentials = accessTokens.filter((accessToken) => accessToken.source === query.service).map((accessToken) => ({
+        service: accessToken.source,
+        apiKey: accessToken.token
+      }));
+      if (caching) {
+        cache.set(cacheKey, credentials);
       }
+      return credentials;
     };
-    const result = functionDef.handler({
-      context,
-      data: input
-    });
-    let data;
-    if (Effect5.isEffect(result)) {
-      data = await result.pipe(Effect5.provide(this._services.createLayer()), runAndForwardErrors);
-    } else {
-      data = await result;
-    }
-    const assertOutput = functionDef.outputSchema?.pipe(Schema9.asserts);
-    assertOutput(data);
-    return data;
-  }
-};
-
-// src/services/function-invocation-service.ts
-import * as Context2 from "effect/Context";
-import * as Effect7 from "effect/Effect";
-import * as Layer2 from "effect/Layer";
-import { AiService as AiService2 } from "@dxos/ai";
-
-// src/services/local-function-execution.ts
-import * as Context from "effect/Context";
-import * as Effect6 from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Schema10 from "effect/Schema";
-import { AiService } from "@dxos/ai";
-import { todo } from "@dxos/debug";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/local-function-execution.ts";
-var LocalFunctionExecutionService = class _LocalFunctionExecutionService extends Context.Tag("@dxos/functions/LocalFunctionExecutionService")() {
-  static layerLive = Layer.effect(_LocalFunctionExecutionService, Effect6.gen(function* () {
-    const resolver = yield* FunctionImplementationResolver;
-    const ai = yield* AiService.AiService;
-    const credentials = yield* CredentialsService;
-    const database = yield* DatabaseService;
-    const queues = yield* QueueService;
-    const functionCallService = yield* RemoteFunctionExecutionService;
     return {
-      // TODO(dmaretskyi): Better error types.
-      invokeFunction: (functionDef, input) => Effect6.gen(function* () {
-        const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect6.orDie);
-        const output = yield* invokeFunction(resolved, input);
-        return output;
-      }).pipe(Effect6.provideService(AiService.AiService, ai), Effect6.provideService(CredentialsService, credentials), Effect6.provideService(DatabaseService, database), Effect6.provideService(QueueService, queues), Effect6.provideService(RemoteFunctionExecutionService, functionCallService))
+      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);
+      }
     };
   }));
-  static invokeFunction = Effect6.serviceFunctionEffect(_LocalFunctionExecutionService, (_) => _.invokeFunction);
 };
-var invokeFunction = (functionDef, input) => Effect6.gen(function* () {
-  try {
-    const assertInput = functionDef.inputSchema.pipe(Schema10.asserts);
-    assertInput(input);
-  } catch (e) {
-    throw new FunctionError({
-      message: "Invalid function input",
-      context: {
-        name: functionDef.name
-      },
-      cause: e
-    });
+var ConfiguredCredentialsService = class {
+  credentials;
+  constructor(credentials = []) {
+    this.credentials = credentials;
   }
-  const context = {
-    space: void 0,
-    getService: () => todo(),
-    getSpace: async (_spaceId) => {
-      throw new Error("Not available. Use the database service instead.");
-    }
-  };
-  log2.info("invoking function", {
-    name: functionDef.name,
-    input
-  }, {
-    F: __dxlog_file,
-    L: 98,
-    S: this,
-    C: (f, a) => f(...a)
-  });
-  const data = yield* Effect6.gen(function* () {
-    const result = functionDef.handler({
-      context,
-      data: input
-    });
-    if (Effect6.isEffect(result)) {
-      return yield* result.pipe(Effect6.orDie);
-    } else if (typeof result === "object" && result !== null && "then" in result && typeof result.then === "function") {
-      return yield* Effect6.promise(() => result);
-    } else {
-      return result;
-    }
-  }).pipe(Effect6.orDie, Effect6.catchAllDefect((defect) => Effect6.die(new FunctionError({
-    context: {
-      name: functionDef.name
-    },
-    cause: defect
-  }))));
-  log2.info("completed", {
-    function: functionDef.name,
-    input,
-    data
-  }, {
-    F: __dxlog_file,
-    L: 122,
-    S: this,
-    C: (f, a) => f(...a)
-  });
-  try {
-    const assertOutput = functionDef.outputSchema?.pipe(Schema10.asserts);
-    assertOutput(data);
-  } catch (e) {
-    throw new FunctionError({
-      message: "Invalid function output",
-      context: {
-        name: functionDef.name
-      },
-      cause: e
-    });
+  addCredentials(credentials) {
+    this.credentials.push(...credentials);
+    return this;
   }
-  return data;
-}).pipe(Effect6.withSpan("invokeFunction", {
-  attributes: {
-    name: functionDef.name
+  async queryCredentials(query) {
+    return this.credentials.filter((credential) => credential.service === query.service);
   }
-}));
-var FunctionImplementationResolver = class _FunctionImplementationResolver extends Context.Tag("@dxos/functions/FunctionImplementationResolver")() {
-  static layerTest = ({ functions }) => Layer.succeed(_FunctionImplementationResolver, {
-    resolveFunctionImplementation: (functionDef) => {
-      const resolved = functions.find((f) => f.key === functionDef.key);
-      if (!resolved) {
-        return Effect6.fail(new FunctionNotFoundError(functionDef.name));
-      }
-      return Effect6.succeed(resolved);
+  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 = (token, kind) => HttpClient.mapRequest((request) => {
+  const authorization = kind ? `${kind} ${token}` : token;
+  return HttpClientRequest.setHeader(request, "Authorization", authorization);
+});
 
-// src/services/function-invocation-service.ts
-var FunctionInvocationService = class _FunctionInvocationService extends Context2.Tag("@dxos/functions/FunctionInvocationService")() {
-  static invokeFunction = Effect7.serviceFunctionEffect(_FunctionInvocationService, (_) => _.invokeFunction);
-  static layer = Layer2.effect(_FunctionInvocationService, Effect7.gen(function* () {
-    const localExecutioner = yield* LocalFunctionExecutionService;
-    const remoteExecutioner = yield* RemoteFunctionExecutionService;
-    return {
-      invokeFunction: (functionDef, input) => Effect7.gen(function* () {
-        if (functionDef.meta?.deployedFunctionId) {
-          return yield* remoteExecutioner.callFunction(functionDef.meta.deployedFunctionId, input);
-        }
-        return yield* localExecutioner.invokeFunction(functionDef, input);
-      })
-    };
-  }));
-  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
-  static layerTest = ({ functions = [] } = {}) => _FunctionInvocationService.layer.pipe(Layer2.provide(LocalFunctionExecutionService.layerLive), Layer2.provide(FunctionImplementationResolver.layerTest({
-    functions
-  })), Layer2.provide(RemoteFunctionExecutionService.layerMock));
-  // TODO(dmaretskyi): This shouldn't default to all services being not available.
-  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
-  /**
-  * @deprecated Use {@link layerTest} instead.
-  */
-  static layerTestMocked = ({ functions }) => _FunctionInvocationService.layerTest({
-    functions
-  }).pipe(Layer2.provide(AiService2.notAvailable), Layer2.provide(CredentialsService.configuredLayer([])), Layer2.provide(DatabaseService.notAvailable), Layer2.provide(QueueService.notAvailable));
-};
+// src/services/event-logger.ts
+import * as Context3 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+import * as Schema9 from "effect/Schema";
+import { Obj as Obj6, Type as Type6 } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { LogLevel, log as log2 } from "@dxos/log";
 
-// src/trace.ts
-import * as Schema11 from "effect/Schema";
-import { Type as Type6 } from "@dxos/echo";
-import { ObjectId } from "@dxos/echo/internal";
-import { Queue } from "@dxos/echo-db";
-import { log as log3 } from "@dxos/log";
-var __dxlog_file2 = "/__w/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 = Schema11.Struct({
-  timestamp: Schema11.Number,
-  message: Schema11.String,
-  name: Schema11.String,
-  stack: Schema11.optional(Schema11.String)
-});
-var InvocationTraceStartEvent = Schema11.Struct({
-  /**
-  * Queue message id.
-  */
-  id: ObjectId,
-  type: Schema11.Literal("start"),
-  /**
-  * Invocation id, the same for invocation start and end events.
-  */
-  invocationId: ObjectId,
+// src/services/tracing.ts
+import * as Context2 from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import { AgentStatus } from "@dxos/ai";
+import { Obj as Obj5 } from "@dxos/echo";
+import { ObjectId } from "@dxos/keys";
+import { Message } from "@dxos/types";
+var TracingService = class _TracingService extends Context2.Tag("@dxos/functions/TracingService")() {
+  static noop = {
+    getTraceContext: () => ({}),
+    write: () => {
+    },
+    traceInvocationStart: () => Effect6.sync(() => ({
+      invocationId: ObjectId.random(),
+      invocationTraceQueue: void 0
+    })),
+    traceInvocationEnd: () => Effect6.sync(() => {
+    })
+  };
+  static layerNoop = Layer2.succeed(_TracingService, _TracingService.noop);
   /**
-  * Event generation time.
+  * Creates a TracingService layer that emits events to the parent tracing service.
   */
-  timestamp: Schema11.Number,
+  static layerSubframe = (mapContext) => Layer2.effect(_TracingService, Effect6.gen(function* () {
+    const tracing = yield* _TracingService;
+    const context = mapContext(tracing.getTraceContext());
+    return {
+      write: (event, context2) => tracing.write(event, context2),
+      getTraceContext: () => context,
+      traceInvocationStart: () => Effect6.die("Tracing invocation inside another invocation is not supported."),
+      traceInvocationEnd: () => Effect6.die("Tracing invocation inside another invocation is not supported.")
+    };
+  }));
   /**
-  * Data passed to function / workflow as an argument.
+  * Create sublayer to trace an invocation.
+  * @param data
+  * @returns
   */
-  // TODO(burdon): Input schema?
-  input: Schema11.Object,
+  static layerInvocation = (data) => _TracingService.layerSubframe((context) => ({
+    ...context,
+    currentInvocation: data
+  }));
   /**
-  * Queue  for function/workflow invocation events.
+  * Emit the current human-readable execution status.
   */
-  invocationTraceQueue: Schema11.optional(Type6.Ref(Queue)),
+  static emitStatus = Effect6.fnUntraced(function* (data) {
+    const tracing = yield* _TracingService;
+    tracing.write(Obj5.make(AgentStatus, {
+      parentMessage: tracing.getTraceContext().parentMessage,
+      toolCallId: tracing.getTraceContext().toolCallId,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      ...data
+    }), tracing.getTraceContext());
+  });
+  static emitConverationMessage = Effect6.fnUntraced(function* (data) {
+    const tracing = yield* _TracingService;
+    tracing.write(Obj5.make(Message.Message, {
+      parentMessage: tracing.getTraceContext().parentMessage,
+      ...data,
+      properties: {
+        [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
+        ...data.properties
+      }
+    }), tracing.getTraceContext());
+  });
+};
+var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
+
+// src/services/event-logger.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/event-logger.ts";
+var ComputeEventPayload = Schema9.Union(Schema9.Struct({
+  type: Schema9.Literal("begin-compute"),
+  nodeId: Schema9.String,
   /**
-  * DXN of the invoked function/workflow.
-  */
-  invocationTarget: Schema11.optional(Type6.Ref(Type6.Expando)),
+   * Names of the inputs begin computed.
+   */
+  inputs: Schema9.Array(Schema9.String)
+}), Schema9.Struct({
+  type: Schema9.Literal("end-compute"),
+  nodeId: Schema9.String,
   /**
-  * Present for automatic invocations.
-  */
-  trigger: Schema11.optional(Type6.Ref(Trigger_exports.Trigger))
-}).pipe(Type6.Obj({
-  typename: "dxos.org/type/InvocationTraceStart",
+   * Names of the outputs computed.
+   */
+  outputs: Schema9.Array(Schema9.String)
+}), Schema9.Struct({
+  type: Schema9.Literal("compute-input"),
+  nodeId: Schema9.String,
+  property: Schema9.String,
+  value: Schema9.Any
+}), Schema9.Struct({
+  type: Schema9.Literal("compute-output"),
+  nodeId: Schema9.String,
+  property: Schema9.String,
+  value: Schema9.Any
+}), Schema9.Struct({
+  type: Schema9.Literal("custom"),
+  nodeId: Schema9.String,
+  event: Schema9.Any
+}));
+var ComputeEvent = Schema9.Struct({
+  payload: ComputeEventPayload
+}).pipe(Type6.object({
+  typename: "dxos.org/type/ComputeEvent",
   version: "0.1.0"
 }));
-var InvocationTraceEndEvent = Schema11.Struct({
-  /**
-  * Trace event id.
-  */
-  id: ObjectId,
-  type: Schema11.Literal("end"),
-  /**
-  * Invocation id, will be the same for invocation start and end.
-  */
-  invocationId: ObjectId,
+var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/functions/ComputeEventLogger")() {
+  static noop = {
+    log: () => {
+    },
+    nodeId: void 0
+  };
   /**
-  * Event generation time.
+  * Implements ComputeEventLogger using TracingService.
   */
-  // TODO(burdon): Remove ms suffix.
-  timestamp: Schema11.Number,
-  outcome: Schema11.Enums(InvocationOutcome),
-  exception: Schema11.optional(TraceEventException)
-}).pipe(Type6.Obj({
-  typename: "dxos.org/type/InvocationTraceEnd",
-  version: "0.1.0"
-}));
-var TraceEventLog = Schema11.Struct({
-  timestamp: Schema11.Number,
-  level: Schema11.String,
-  message: Schema11.String,
-  context: Schema11.optional(Schema11.Object)
-});
-var TraceEvent = Schema11.Struct({
-  id: ObjectId,
-  // TODO(burdon): Need enum/numeric result (not string).
-  outcome: Schema11.String,
-  truncated: Schema11.Boolean,
-  /** Time when the event was persisted. */
-  ingestionTimestamp: Schema11.Number,
-  logs: Schema11.Array(TraceEventLog),
-  exceptions: Schema11.Array(TraceEventException)
-}).pipe(Type6.Obj({
-  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;
-    }
-    const invocationId = event.invocationId;
-    const entry = eventsByInvocationId.get(invocationId) || {
-      start: void 0,
-      end: void 0
+  static layerFromTracing = Layer3.effect(_ComputeEventLogger, Effect7.gen(function* () {
+    const tracing = yield* TracingService;
+    return {
+      log: (event) => {
+        tracing.write(Obj6.make(ComputeEvent, {
+          payload: event
+        }), tracing.getTraceContext());
+      },
+      nodeId: 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) {
-      log3.warn("found end event without matching start", {
-        invocationId
-      }, {
-        F: __dxlog_file2,
-        L: 158,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      continue;
-    }
-    const isInProgress = end === void 0;
-    result.push({
-      id: invocationId,
-      timestamp: start.timestamp,
-      duration: isInProgress ? now - start.timestamp : end.timestamp - start.timestamp,
-      outcome: end?.outcome ?? "pending",
-      exception: end?.exception,
-      input: start.input,
-      invocationTraceQueue: start.invocationTraceQueue,
-      invocationTarget: start.invocationTarget,
-      trigger: start.trigger
-    });
+  }));
+};
+var logCustomEvent = (data) => Effect7.gen(function* () {
+  const logger = yield* ComputeEventLogger;
+  if (!logger.nodeId) {
+    throw new Error("logCustomEvent must be called within a node compute function");
   }
-  return result;
+  logger.log({
+    type: "custom",
+    nodeId: logger.nodeId,
+    event: data
+  });
+});
+var createDefectLogger = () => Effect7.catchAll((error) => Effect7.gen(function* () {
+  log2.error("unhandled effect error", {
+    error
+  }, {
+    F: __dxlog_file,
+    L: 102,
+    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];
+  invariant(logFunction, void 0, {
+    F: __dxlog_file,
+    L: 120,
+    S: void 0,
+    A: [
+      "logFunction",
+      ""
+    ]
+  });
+  return {
+    log: (event) => {
+      logFunction(message, event);
+    },
+    nodeId: void 0
+  };
 };
 
-// src/triggers/invocation-tracer.ts
-import * as Context3 from "effect/Context";
+// src/services/function-invocation-service.ts
+import * as Context4 from "effect/Context";
 import * as Effect8 from "effect/Effect";
-import * as Layer3 from "effect/Layer";
-import { Obj as Obj6, Ref as Ref4 } from "@dxos/echo";
-import { DXN as DXN3, ObjectId as ObjectId2 } from "@dxos/keys";
-var InvocationTracer = class _InvocationTracer extends Context3.Tag("@dxos/functions/InvocationTracer")() {
-  static layerLive = (opts) => Layer3.effect(_InvocationTracer, Effect8.gen(function* () {
-    return {
-      traceInvocationStart: Effect8.fn("traceInvocationStart")(function* ({ payload, target }) {
-        const invocationId = ObjectId2.random();
-        const invocationTraceQueue = yield* QueueService.createQueue({
-          subspaceTag: "trace"
-        });
-        const now = Date.now();
-        const traceEvent = Obj6.make(InvocationTraceStartEvent, {
-          type: InvocationTraceEventType.START,
-          invocationId,
-          timestamp: now,
-          // TODO(dmaretskyi): Not json-stringifying this makes ECHO fail when one ECHO object becomes embedded in another ECHO object.
-          input: JSON.parse(JSON.stringify(payload.data ?? {})),
-          invocationTraceQueue: Ref4.fromDXN(invocationTraceQueue.dxn),
-          invocationTarget: target ? Ref4.fromDXN(target) : void 0,
-          trigger: payload.trigger ? Ref4.fromDXN(DXN3.fromLocalObjectId(payload.trigger.id)) : void 0
-        });
-        yield* QueueService.append(opts.invocationTraceQueue, [
-          traceEvent
-        ]);
-        return {
-          invocationId,
-          invocationTraceQueue
-        };
-      }),
-      traceInvocationEnd: Effect8.fn("traceInvocationEnd")(function* ({ trace, exception }) {
-        const now = Date.now();
-        const traceEvent = Obj6.make(InvocationTraceEndEvent, {
-          type: InvocationTraceEventType.END,
-          invocationId: trace.invocationId,
-          timestamp: now,
-          outcome: exception ? InvocationOutcome.FAILURE : InvocationOutcome.SUCCESS,
-          exception: exception ? {
-            name: exception.constructor.name,
-            timestamp: now,
-            message: exception?.message ?? "Unknown error",
-            stack: exception?.stack
-          } : void 0
-        });
-        yield* QueueService.append(opts.invocationTraceQueue, [
-          traceEvent
-        ]);
-      })
-    };
-  }));
-  static layerTest = Layer3.unwrapEffect(Effect8.gen(function* () {
-    const queue = yield* QueueService.createQueue({
-      subspaceTag: "trace"
-    });
-    return _InvocationTracer.layerLive({
-      invocationTraceQueue: queue
-    });
-  }));
+import * as Layer4 from "effect/Layer";
+var FunctionInvocationService = class _FunctionInvocationService extends Context4.Tag("@dxos/functions/FunctionInvocationService")() {
+  static layerNotAvailable = Layer4.succeed(_FunctionInvocationService, {
+    invokeFunction: () => Effect8.die("FunctionInvocationService is not avaialble."),
+    resolveFunction: () => Effect8.die("FunctionInvocationService is not available.")
+  });
+  static invokeFunction = (functionDef, input) => Effect8.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+  static resolveFunction = (key) => Effect8.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key);
 };
 
-// src/triggers/trigger-dispatcher.ts
-import * as Cause from "effect/Cause";
+// src/services/queues.ts
 import * as Context5 from "effect/Context";
-import * as Cron from "effect/Cron";
-import * as Duration from "effect/Duration";
-import * as Effect10 from "effect/Effect";
-import * as Either from "effect/Either";
-import * as Exit from "effect/Exit";
-import * as Fiber from "effect/Fiber";
+import * as Effect9 from "effect/Effect";
 import * as Layer5 from "effect/Layer";
-import * as Option2 from "effect/Option";
-import * as Record4 from "effect/Record";
-import * as Schedule from "effect/Schedule";
-import { DXN as DXN4, Filter, Obj as Obj7, Query } from "@dxos/echo";
-import { causeToError } from "@dxos/effect";
-import { invariant } from "@dxos/invariant";
-import { log as log4 } from "@dxos/log";
-import { KEY_QUEUE_POSITION } from "@dxos/protocols";
-
-// src/triggers/input-builder.ts
-var createInvocationPayload = (trigger, event) => {
-  if (!trigger.input) {
-    return event;
-  }
-  const payload = {};
-  for (const [key, value] of Object.entries(trigger.input)) {
-    if (typeof value !== "string" || !(value.startsWith("{{") && value.endsWith("}}"))) {
-      payload[key] = value;
-      continue;
-    }
-    const propertyPath = value.slice(2, -2);
-    let valueSubstitution = propertyPath.startsWith("trigger.") ? trigger : propertyPath.startsWith("event.") ? event : void 0;
-    for (const pathSegment of propertyPath.split(".").slice(1)) {
-      if (valueSubstitution && typeof valueSubstitution === "object") {
-        valueSubstitution = valueSubstitution[pathSegment];
+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");
       }
-    }
-    payload[key] = valueSubstitution;
-  }
-  return payload;
-};
-
-// src/triggers/trigger-state-store.ts
-import * as KeyValueStore from "@effect/platform/KeyValueStore";
-import * as Context4 from "effect/Context";
-import * as Effect9 from "effect/Effect";
-import * as Layer4 from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schema12 from "effect/Schema";
-import { ObjectId as ObjectId3 } from "@dxos/keys";
-var TriggerState = Schema12.Struct({
-  version: Schema12.Literal("1"),
-  triggerId: Schema12.String,
-  state: Schema12.optional(Schema12.Union(Schema12.TaggedStruct("subscription", {
-    processedVersions: Schema12.Record({
-      key: ObjectId3,
-      value: Schema12.String
-    })
-  })))
-});
-var TriggerStateStore = class _TriggerStateStore extends Context4.Tag("@dxos/functions/TriggerStateStore")() {
-  static getState = Effect9.serviceFunctionEffect(_TriggerStateStore, (_) => _.getState);
-  static saveState = Effect9.serviceFunctionEffect(_TriggerStateStore, (_) => _.saveState);
-  static layerKv = Layer4.effect(_TriggerStateStore, Effect9.gen(function* () {
-    const kv = yield* KeyValueStore.KeyValueStore;
-    const schemaStore = kv.forSchema(Schema12.parseJson(TriggerState));
-    const store = {
-      getState: Effect9.fn("TriggerStateStore.getState")(function* (triggerId) {
-        const valueOption = yield* schemaStore.get(triggerId).pipe(Effect9.orDie);
-        if (Option.isNone(valueOption)) {
-          return yield* Effect9.fail(new TriggerStateNotFoundError());
-        }
-        return valueOption.value;
-      }),
-      saveState: Effect9.fn("TriggerStateStore.saveState")(function* (state) {
-        yield* schemaStore.set(state.triggerId, state).pipe(Effect9.orDie);
-      })
+    },
+    queue: void 0
+  });
+  static make = (queues, queue) => {
+    return {
+      queues,
+      queue
     };
-    return store;
-  }));
-  static layerMemory = _TriggerStateStore.layerKv.pipe(Layer4.provide(KeyValueStore.layerMemory));
+  };
+  static layer = (queues, queue) => Layer5.succeed(_QueueService, _QueueService.make(queues, queue));
+  /**
+  * Gets a queue by its DXN.
+  */
+  static getQueue = (dxn) => _QueueService.pipe(Effect9.map(({ queues }) => queues.get(dxn)));
+  /**
+  * Creates a new queue.
+  */
+  static createQueue = (options) => _QueueService.pipe(Effect9.map(({ queues }) => queues.create(options)));
+  static append = (queue, objects) => Effect9.promise(() => queue.append(objects));
 };
-
-// src/triggers/trigger-dispatcher.ts
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/triggers/trigger-dispatcher.ts";
-var TriggerDispatcher = class _TriggerDispatcher extends Context5.Tag("@dxos/functions/TriggerDispatcher")() {
-  static layer = (options) => Layer5.effect(_TriggerDispatcher, Effect10.gen(function* () {
-    return new TriggerDispatcherImpl(options);
-  }));
+var ContextQueueService = class _ContextQueueService extends Context5.Tag("@dxos/functions/ContextQueueService")() {
+  static layer = (queue) => Layer5.succeed(_ContextQueueService, {
+    queue
+  });
 };
-var TriggerDispatcherImpl = class {
-  livePollInterval;
-  timeControl;
-  _running = false;
-  _internalTime;
-  _timerFiber;
-  _scheduledTriggers = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.timeControl = options.timeControl;
-    this.livePollInterval = options.livePollInterval ?? Duration.seconds(1);
-    this._internalTime = options.startingTime ?? /* @__PURE__ */ new Date();
-  }
-  get running() {
-    return this._running;
-  }
-  start = () => Effect10.gen(this, function* () {
-    if (this._running) {
-      return;
-    }
-    this._running = true;
-    if (this.timeControl === "natural") {
-      this._timerFiber = yield* this._startNaturalTimeProcessing().pipe(Effect10.tapErrorCause((cause) => {
-        const error = causeToError(cause);
-        log4.error("trigger dispatcher error", {
-          error
+
+// src/protocol/protocol.ts
+import * as AnthropicClient from "@effect/ai-anthropic/AnthropicClient";
+import * as Effect11 from "effect/Effect";
+import * as Layer7 from "effect/Layer";
+import * as Schema10 from "effect/Schema";
+import * as SchemaAST2 from "effect/SchemaAST";
+import { AiModelResolver, AiService } from "@dxos/ai";
+import { AnthropicResolver } from "@dxos/ai/resolvers";
+import { LifecycleState, Resource } from "@dxos/context";
+import { Database as Database2, Ref as Ref2, Type as Type7 } from "@dxos/echo";
+import { refFromEncodedReference } from "@dxos/echo/internal";
+import { EchoClient } from "@dxos/echo-db";
+import { runAndForwardErrors } from "@dxos/effect";
+import { assertState, failedInvariant as failedInvariant2, invariant as invariant2 } from "@dxos/invariant";
+import { PublicKey } from "@dxos/keys";
+
+// src/protocol/functions-ai-http-client.ts
+import * as Headers from "@effect/platform/Headers";
+import * as HttpClient2 from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect10 from "effect/Effect";
+import * as FiberRef from "effect/FiberRef";
+import * as Layer6 from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { log as log3 } from "@dxos/log";
+import { ErrorCodec } from "@dxos/protocols";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/protocol/functions-ai-http-client.ts";
+var requestInitTagKey = "@effect/platform/FetchHttpClient/FetchOptions";
+var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
+  static make = (service) => HttpClient2.make((request, url, signal, fiber) => {
+    const context = fiber.getFiberRef(FiberRef.currentContext);
+    const options = context.unsafeMap.get(requestInitTagKey) ?? {};
+    const headers = options.headers ? Headers.merge(Headers.fromInput(options.headers), request.headers) : request.headers;
+    const send = (body) => Effect10.tryPromise({
+      try: () => service.fetch(new Request(url, {
+        ...options,
+        method: request.method,
+        headers,
+        body
+      })),
+      catch: (cause) => {
+        log3.error("Failed to fetch", {
+          errorSerialized: ErrorCodec.encode(cause)
         }, {
-          F: __dxlog_file3,
-          L: 178,
+          F: __dxlog_file2,
+          L: 43,
           S: this,
           C: (f, a) => f(...a)
         });
-        this._running = false;
-        return Effect10.void;
-      }), Effect10.forkDaemon);
-    } else {
-      return yield* Effect10.dieMessage("TriggerDispatcher started in manual time control mode");
+        return new HttpClientError.RequestError({
+          request,
+          reason: "Transport",
+          cause
+        });
+      }
+    }).pipe(Effect10.map((response) => HttpClientResponse.fromWeb(request, response)));
+    switch (request.body._tag) {
+      case "Raw":
+      case "Uint8Array":
+        return send(request.body.body);
+      case "FormData":
+        return send(request.body.formData);
+      case "Stream":
+        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect10.flatMap(send));
     }
-    log4.info("TriggerDispatcher started", {
-      timeControl: this.timeControl
-    }, {
-      F: __dxlog_file3,
-      L: 188,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    return send(void 0);
   });
-  stop = () => Effect10.gen(this, function* () {
-    if (!this._running) {
-      return;
+  static layer = (service) => Layer6.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
+};
+
+// src/protocol/protocol.ts
+function _ts_add_disposable_resource(env, value2, async) {
+  if (value2 !== null && value2 !== void 0) {
+    if (typeof value2 !== "object" && typeof value2 !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value2[Symbol.asyncDispose];
     }
-    this._running = false;
-    if (this._timerFiber) {
-      yield* Fiber.interrupt(this._timerFiber);
-      this._timerFiber = void 0;
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value2[Symbol.dispose];
+      if (async) inner = dispose;
     }
-    this._scheduledTriggers.clear();
-    log4.info("TriggerDispatcher stopped", void 0, {
-      F: __dxlog_file3,
-      L: 208,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  });
-  invokeTrigger = (options) => Effect10.gen(this, function* () {
-    const { trigger, event } = options;
-    log4.info("running trigger", {
-      triggerId: trigger.id,
-      spec: trigger.spec,
-      event
-    }, {
-      F: __dxlog_file3,
-      L: 216,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const tracer = yield* InvocationTracer;
-    const trace = yield* tracer.traceInvocationStart({
-      target: trigger.function?.dxn,
-      payload: {
-        trigger: {
-          id: trigger.id,
-          // TODO(dmaretskyi): Is `spec` always there>
-          kind: trigger.spec.kind
-        },
-        data: event
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
       }
+    };
+    env.stack.push({
+      value: value2,
+      dispose,
+      async
     });
-    const result = yield* Effect10.gen(this, function* () {
-      if (!trigger.enabled) {
-        return yield* Effect10.dieMessage("Attempting to invoke disabled trigger");
-      }
-      if (!trigger.function) {
-        return yield* Effect10.dieMessage("Trigger has no function reference");
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value2;
+}
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
       }
-      const serialiedFunction = yield* DatabaseService.load(trigger.function).pipe(Effect10.orDie);
-      invariant(Obj7.instanceOf(Function_exports.Function, serialiedFunction), void 0, {
-        F: __dxlog_file3,
-        L: 243,
-        S: this,
-        A: [
-          "Obj.instanceOf(Function.Function, serialiedFunction)",
-          ""
-        ]
-      });
-      const functionDef = deserializeFunction(serialiedFunction);
-      const inputData = this._prepareInputData(trigger, event);
-      return yield* FunctionInvocationService.invokeFunction(functionDef, inputData).pipe(Effect10.provide(ComputeEventLogger.layerFromTracing.pipe(Layer5.provideMerge(TracingService.layerQueue(trace.invocationTraceQueue)))));
-    }).pipe(Effect10.exit);
-    const triggerExecutionResult = {
-      triggerId: trigger.id,
-      result
-    };
-    if (Exit.isSuccess(result)) {
-      log4.info("trigger execution success", {
-        triggerId: trigger.id
-      }, {
-        F: __dxlog_file3,
-        L: 264,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    } else {
-      log4.error("trigger execution failure", {
-        error: causeToError(result.cause)
-      }, {
-        F: __dxlog_file3,
-        L: 268,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
     }
-    yield* tracer.traceInvocationEnd({
-      trace,
-      // TODO(dmaretskyi): Might miss errors.
-      exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : void 0
-    });
-    return triggerExecutionResult;
-  });
-  invokeScheduledTriggers = ({ kinds = [
-    "timer",
-    "queue",
-    "subscription"
-  ] } = {}) => Effect10.gen(this, function* () {
-    const invocations = [];
-    for (const kind of kinds) {
-      switch (kind) {
-        case "timer":
-          {
-            yield* this.refreshTriggers();
-            const now = this.getCurrentTime();
-            const triggersToInvoke = [];
-            for (const [triggerId, scheduledTrigger] of this._scheduledTriggers.entries()) {
-              if (scheduledTrigger.nextExecution <= now) {
-                triggersToInvoke.push(scheduledTrigger.trigger);
-                scheduledTrigger.nextExecution = Cron.next(scheduledTrigger.cron, now);
-              }
-            }
-            invocations.push(...yield* Effect10.forEach(triggersToInvoke, (trigger) => this.invokeTrigger({
-              trigger,
-              event: {
-                tick: now.getTime()
-              }
-            }), {
-              concurrency: 1
-            }));
-          }
-          break;
-        case "queue": {
-          const triggers = yield* this._fetchTriggers();
-          for (const trigger of triggers) {
-            const spec = trigger.spec;
-            if (spec?.kind !== "queue") {
-              continue;
-            }
-            const cursor = Obj7.getKeys(trigger, KEY_QUEUE_CURSOR).at(0)?.id;
-            const queue = yield* QueueService.getQueue(DXN4.parse(spec.queue));
-            const objects = yield* Effect10.promise(() => queue.queryObjects());
-            for (const object of objects) {
-              const objectPos = Obj7.getKeys(object, KEY_QUEUE_POSITION).at(0)?.id;
-              if (!objectPos || cursor && parseInt(cursor) >= parseInt(objectPos)) {
-                continue;
-              }
-              invocations.push(yield* this.invokeTrigger({
-                trigger,
-                event: {
-                  queue: spec.queue,
-                  item: object,
-                  cursor: objectPos
-                }
-              }));
-              Obj7.deleteKeys(trigger, KEY_QUEUE_CURSOR);
-              Obj7.getMeta(trigger).keys.push({
-                source: KEY_QUEUE_CURSOR,
-                id: objectPos
+    return next();
+  })(env);
+}
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
+var wrapFunctionHandler = (func) => {
+  if (!FunctionDefinition.isFunction(func)) {
+    throw new TypeError("Invalid function definition");
+  }
+  return {
+    meta: {
+      key: func.key,
+      name: func.name,
+      description: func.description,
+      inputSchema: Type7.toJsonSchema(func.inputSchema),
+      outputSchema: func.outputSchema === void 0 ? void 0 : Type7.toJsonSchema(func.outputSchema),
+      services: func.services
+    },
+    handler: async ({ data, context }) => {
+      if ((func.services.includes(Database2.Service.key) || func.services.includes(QueueService.key)) && (!context.services.dataService || !context.services.queryService)) {
+        throw new FunctionError({
+          message: "Services not provided: dataService, queryService"
+        });
+      }
+      try {
+        const env = {
+          stack: [],
+          error: void 0,
+          hasError: false
+        };
+        try {
+          if (!SchemaAST2.isAnyKeyword(func.inputSchema.ast)) {
+            try {
+              Schema10.validateSync(func.inputSchema)(data);
+            } catch (error) {
+              throw new FunctionError({
+                message: "Invalid input schema",
+                cause: error
               });
-              yield* DatabaseService.flush();
-              break;
             }
           }
-          break;
-        }
-        case "subscription": {
-          const triggers = yield* this._fetchTriggers();
-          for (const trigger of triggers) {
-            const spec = Obj7.getSnapshot(trigger).spec;
-            if (spec?.kind !== "subscription") {
-              continue;
-            }
-            const { objects } = yield* DatabaseService.runQuery(Query.fromAst(spec.query.ast));
-            const state = yield* TriggerStateStore.getState(trigger.id).pipe(Effect10.catchTag("TRIGGER_STATE_NOT_FOUND", () => Effect10.succeed({
-              version: "1",
-              triggerId: trigger.id,
-              state: {
-                _tag: "subscription",
-                processedVersions: {}
-              }
-            })));
-            invariant(state.state?._tag === "subscription", void 0, {
+          const funcContext = _ts_add_disposable_resource(env, await new FunctionContext(context).open(), true);
+          if (func.types.length > 0) {
+            invariant2(funcContext.db, "Database is required for functions with types", {
               F: __dxlog_file3,
-              L: 381,
-              S: this,
+              L: 68,
+              S: void 0,
               A: [
-                "state.state?._tag === 'subscription'",
-                ""
+                "funcContext.db",
+                "'Database is required for functions with types'"
               ]
             });
-            let updated = false;
-            for (const object of objects) {
-              const existingVersion = Record4.get(state.state.processedVersions, object.id).pipe(Option2.map(Obj7.decodeVersion));
-              const currentVersion = Obj7.version(object);
-              const run = Option2.isNone(existingVersion) || Obj7.compareVersions(currentVersion, existingVersion.value) === "different";
-              if (!run) {
-                continue;
-              }
-              const { db } = yield* DatabaseService;
-              invocations.push(yield* this.invokeTrigger({
-                trigger,
-                event: {
-                  // TODO(dmaretskyi): Change type not supported.
-                  type: "unknown",
-                  subject: db.ref(Obj7.getDXN(object)),
-                  changedObjectId: object.id
-                }
-              }));
-              state.state.processedVersions[object.id] = Obj7.encodeVersion(currentVersion);
-              updated = true;
-            }
-            if (updated) {
-              yield* TriggerStateStore.saveState(state);
-            }
+            await funcContext.db.graph.schemaRegistry.register(func.types);
           }
-          break;
-        }
-        default: {
-          return yield* Effect10.dieMessage(`Unknown trigger kind: ${kind}`);
+          const dataWithDecodedRefs = funcContext.db && !SchemaAST2.isAnyKeyword(func.inputSchema.ast) ? decodeRefsFromSchema(func.inputSchema.ast, data, funcContext.db) : data;
+          let result = await func.handler({
+            // TODO(dmaretskyi): Fix the types.
+            context,
+            data: dataWithDecodedRefs
+          });
+          if (Effect11.isEffect(result)) {
+            result = await runAndForwardErrors(result.pipe(Effect11.orDie, Effect11.provide(funcContext.createLayer())));
+          }
+          if (func.outputSchema && !SchemaAST2.isAnyKeyword(func.outputSchema.ast)) {
+            Schema10.validateSync(func.outputSchema)(result);
+          }
+          return result;
+        } catch (e) {
+          env.error = e;
+          env.hasError = true;
+        } finally {
+          const result = _ts_dispose_resources(env);
+          if (result) await result;
         }
+      } catch (error) {
+        throw error;
       }
     }
-    return invocations;
-  });
-  advanceTime = (duration) => Effect10.gen(this, function* () {
-    if (this.timeControl !== "manual") {
-      return yield* Effect10.dieMessage("advanceTime can only be used in manual time control mode");
+  };
+};
+var FunctionContext = class extends Resource {
+  context;
+  client;
+  db;
+  queues;
+  constructor(context) {
+    super();
+    this.context = context;
+    if (context.services.dataService && context.services.queryService) {
+      this.client = new EchoClient().connectToService({
+        dataService: context.services.dataService,
+        queryService: context.services.queryService,
+        queueService: context.services.queueService
+      });
     }
-    const millis = Duration.toMillis(duration);
-    this._internalTime = new Date(this._internalTime.getTime() + millis);
-    log4("Advanced internal time", {
-      newTime: this._internalTime,
-      advancedBy: Duration.format(duration)
-    }, {
-      F: __dxlog_file3,
-      L: 438,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }).pipe(Effect10.orDie);
-  getCurrentTime = () => {
-    if (this.timeControl === "natural") {
-      return /* @__PURE__ */ new Date();
-    } else {
-      return new Date(this._internalTime);
+  }
+  async _open() {
+    await this.client?.open();
+    this.db = this.client && this.context.spaceId ? this.client.constructDatabase({
+      spaceId: this.context.spaceId ?? failedInvariant2(),
+      spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant2("spaceKey missing in context")),
+      reactiveSchemaQuery: false,
+      preloadSchemaOnOpen: false
+    }) : void 0;
+    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant2("spaceRootUrl missing in context"));
+    await this.db?.open();
+    this.queues = this.client && this.context.spaceId ? this.client.constructQueueFactory(this.context.spaceId) : void 0;
+  }
+  async _close() {
+    await this.db?.close();
+    await this.client?.close();
+  }
+  createLayer() {
+    assertState(this._lifecycleState === LifecycleState.OPEN, "FunctionContext is not open");
+    const dbLayer = this.db ? Database2.Service.layer(this.db) : Database2.Service.notAvailable;
+    const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
+    const credentials = dbLayer ? CredentialsService.layerFromDatabase({
+      caching: true
+    }).pipe(Layer7.provide(dbLayer)) : CredentialsService.configuredLayer([]);
+    const functionInvocationService = MockedFunctionInvocationService;
+    const tracing = TracingService.layerNoop;
+    const aiLayer = this.context.services.functionsAiService ? AiModelResolver.AiModelResolver.buildAiService.pipe(Layer7.provide(AnthropicResolver.make().pipe(Layer7.provide(AnthropicClient.layer({
+      // Note: It doesn't matter what is base url here, it will be proxied to ai gateway in edge.
+      apiUrl: "http://internal/provider/anthropic"
+    }).pipe(Layer7.provide(FunctionsAiHttpClient.layer(this.context.services.functionsAiService))))))) : AiService.notAvailable;
+    return Layer7.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiLayer, tracing);
+  }
+};
+var MockedFunctionInvocationService = Layer7.succeed(FunctionInvocationService, {
+  invokeFunction: () => Effect11.die("Calling functions from functions is not implemented yet."),
+  resolveFunction: () => Effect11.die("Not implemented.")
+});
+var decodeRefsFromSchema = (ast, value2, db) => {
+  if (value2 == null) {
+    return value2;
+  }
+  const encoded = SchemaAST2.encodedBoundAST(ast);
+  if (Ref2.isRefType(encoded)) {
+    if (Ref2.isRef(value2)) {
+      return value2;
     }
-  };
-  refreshTriggers = () => Effect10.gen(this, function* () {
-    const triggers = yield* this._fetchTriggers();
-    const currentTriggerIds = new Set(triggers.map((t) => t.id));
-    for (const triggerId of this._scheduledTriggers.keys()) {
-      if (!currentTriggerIds.has(triggerId)) {
-        this._scheduledTriggers.delete(triggerId);
-      }
+    if (typeof value2 === "object" && value2 !== null && typeof value2["/"] === "string") {
+      const resolver = db.graph.createRefResolver({
+        context: {
+          space: db.spaceId
+        }
+      });
+      return refFromEncodedReference(value2, resolver);
     }
-    for (const trigger of triggers) {
-      if (trigger.spec?.kind === "timer" && trigger.enabled) {
-        const timerSpec = trigger.spec;
-        const cronEither = Cron.parse(timerSpec.cron);
-        if (Either.isRight(cronEither)) {
-          const cron = cronEither.right;
-          const existing = this._scheduledTriggers.get(trigger.id);
-          const now = this.getCurrentTime();
-          const nextExecution = existing?.nextExecution ?? Cron.next(cron, now);
-          log4("Updated scheduled trigger", {
-            triggerId: trigger.id,
-            cron: timerSpec.cron,
-            nextExecution,
-            now
-          }, {
-            F: __dxlog_file3,
-            L: 478,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._scheduledTriggers.set(trigger.id, {
-            trigger,
-            cron,
-            nextExecution
-          });
-        } else {
-          log4.error("Invalid cron expression", {
-            triggerId: trigger.id,
-            cron: timerSpec.cron,
-            error: cronEither.left.message
-          }, {
-            F: __dxlog_file3,
-            L: 490,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+    return value2;
+  }
+  switch (encoded._tag) {
+    case "TypeLiteral": {
+      if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) {
+        return value2;
+      }
+      const result = {
+        ...value2
+      };
+      for (const prop of SchemaAST2.getPropertySignatures(encoded)) {
+        const key = prop.name.toString();
+        if (key in result) {
+          result[key] = decodeRefsFromSchema(prop.type, result[key], db);
         }
       }
+      return result;
     }
-    log4("Updated scheduled triggers", {
-      count: this._scheduledTriggers.size
-    }, {
-      F: __dxlog_file3,
-      L: 499,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }).pipe(Effect10.withSpan("TriggerDispatcher.refreshTriggers"));
-  _fetchTriggers = () => Effect10.gen(this, function* () {
-    const { objects } = yield* DatabaseService.runQuery(Filter.type(Trigger_exports.Trigger));
-    return objects;
-  }).pipe(Effect10.withSpan("TriggerDispatcher.fetchTriggers"));
-  _startNaturalTimeProcessing = () => Effect10.gen(this, function* () {
-    yield* this.invokeScheduledTriggers();
-  }).pipe(Effect10.repeat(Schedule.fixed(this.livePollInterval)), Effect10.asVoid);
-  _prepareInputData = (trigger, event) => {
-    return createInvocationPayload(trigger, event);
-  };
+    case "TupleType": {
+      if (!Array.isArray(value2)) {
+        return value2;
+      }
+      if (encoded.elements.length === 0 && encoded.rest.length === 1) {
+        const elementType = encoded.rest[0].type;
+        return value2.map((item) => decodeRefsFromSchema(elementType, item, db));
+      }
+      return value2;
+    }
+    case "Union": {
+      const nonUndefined = encoded.types.filter((t) => !SchemaAST2.isUndefinedKeyword(t));
+      if (nonUndefined.length === 1) {
+        return decodeRefsFromSchema(nonUndefined[0], value2, db);
+      }
+      return value2;
+    }
+    case "Suspend": {
+      return decodeRefsFromSchema(encoded.f(), value2, db);
+    }
+    case "Refinement": {
+      return decodeRefsFromSchema(encoded.from, value2, db);
+    }
+    default: {
+      return value2;
+    }
+  }
 };
-var KEY_QUEUE_CURSOR = "dxos.org/key/local-trigger-dispatcher/queue-cursor";
 export {
   ComputeEvent,
   ComputeEventLogger,
@@ -1298,50 +1199,32 @@ export {
   ConfiguredCredentialsService,
   ContextQueueService,
   CredentialsService,
-  DatabaseService,
   Example,
   FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
   Function_exports as Function,
   FunctionDefinition,
   FunctionError,
-  FunctionExecutor,
-  FunctionImplementationResolver,
   FunctionInvocationService,
   FunctionNotFoundError,
-  InvocationOutcome,
-  InvocationTraceEndEvent,
-  InvocationTraceEventType,
-  InvocationTraceStartEvent,
-  InvocationTracer,
-  LocalFunctionExecutionService,
   MESSAGE_PROPERTY_TOOL_CALL_ID,
   QueueService,
-  RemoteFunctionExecutionService,
-  SERVICE_TAGS,
   Script_exports as Script,
-  ServiceContainer,
   ServiceNotAvailableError,
-  TraceEvent,
-  TraceEventException,
-  TraceEventLog,
   TracingService,
   Trigger_exports as Trigger,
-  TriggerDispatcher,
   TriggerEvent_exports as TriggerEvent,
-  TriggerState,
   TriggerStateNotFoundError,
-  TriggerStateStore,
   createDefectLogger,
   createEventLogger,
-  createInvocationSpans,
   defineFunction,
   deserializeFunction,
-  getInvocationUrl,
   getUserFunctionIdInMetadata,
   logCustomEvent,
   serializeFunction,
   setUserFunctionIdInMetadata,
-  withAuthorization
+  toOperation,
+  withAuthorization,
+  wrapFunctionHandler
 };
 //# sourceMappingURL=index.mjs.map