@dxos/functions 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/dist/lib/neutral/index.mjs

@@ -1,376 +1,13 @@
-import {
-  EventType,
-  OperationEnd,
-  OperationStart,
-  Trace_exports,
-  write,
-  writerLayerNoop
-} from "./chunk-5T7GOX2V.mjs";
-import {
-  Fibonacci,
-  Reply,
-  Sleep
-} from "./chunk-IVDUS56O.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// 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,
-      message: `Service not available: ${service}`
-    });
-  }
-};
-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/index.ts
-import { OperationHandlerSet } from "@dxos/operation";
-var ExampleHandlers = OperationHandlerSet.lazy(() => import("./fib-N45KAC7C.mjs"), () => import("./reply-EUEPKNJF.mjs"), () => import("./sleep-PUK3D4FF.mjs"));
-
-// src/process/Process.ts
-var Process_exports = {};
-__export(Process_exports, {
-  ExitedEvent: () => ExitedEvent,
-  ID: () => ID,
-  ProcessMonitorService: () => ProcessMonitorService,
-  ProcessTypeId: () => ProcessTypeId,
-  SpawnedEvent: () => SpawnedEvent,
-  State: () => State,
-  fromOperation: () => fromOperation,
-  isProcess: () => isProcess,
-  make: () => make,
-  prettyProcessTree: () => prettyProcessTree
-});
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { assertArgument } from "@dxos/invariant";
-import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/operation";
-var ID = Schema.String.pipe(Schema.brand("ProcessId"));
-var ProcessTypeId = "~@dxos/functions/Process";
-var isProcess = (executable) => typeof executable === "object" && executable !== null && ProcessTypeId in executable;
-var make = (opts, create) => {
-  assertArgument(/^[a-z0-9]([a-z0-9.\-/]*[a-z0-9])?$/i.test(opts.key), "key", "Invalid key");
-  return {
-    [ProcessTypeId]: {},
-    ...opts,
-    create: (ctx) => create(ctx).pipe(Effect.map((partial) => ({
-      onSpawn: () => Effect.void,
-      onInput: () => Effect.void,
-      onAlarm: () => Effect.void,
-      onChildEvent: () => Effect.void,
-      ...partial
-    })))
-  };
-};
-var fromOperation = (op, handler) => make({
-  key: op.meta.key,
-  input: op.input,
-  output: op.output,
-  services: op.services
-}, (ctx) => Effect.gen(function* () {
-  const semaphore = yield* Effect.makeSemaphore(1);
-  return {
-    onInput: (input) => Effect.gen(function* () {
-      yield* write(OperationStart, {
-        key: op.meta.key,
-        name: op.meta.name
-      });
-      const opHandler = yield* OperationHandlerSet2.getHandler(handler, op).pipe(Effect.orDie);
-      const output = yield* opHandler.handler(input).pipe(Effect.orDie);
-      ctx.submitOutput(output);
-      ctx.succeed();
-      yield* write(OperationEnd, {
-        key: op.meta.key,
-        name: op.meta.name,
-        outcome: "success"
-      });
-    }).pipe(Effect.catchAllDefect((defect) => Effect.gen(function* () {
-      const errorMessage = defect instanceof Error ? defect.message : String(defect);
-      yield* write(OperationEnd, {
-        key: op.meta.key,
-        name: op.meta.name,
-        outcome: "failure",
-        error: errorMessage
-      });
-      return yield* Effect.die(defect);
-    })), semaphore.withPermits(1))
-  };
-}));
-var State = /* @__PURE__ */ (function(State2) {
-  State2["RUNNING"] = "RUNNING";
-  State2["HYBERNATING"] = "HYBERNATING";
-  State2["IDLE"] = "IDLE";
-  State2["TERMINATING"] = "TERMINATING";
-  State2["TERMINATED"] = "TERMINATED";
-  State2["SUCCEEDED"] = "SUCCEEDED";
-  State2["FAILED"] = "FAILED";
-  return State2;
-})({});
-var ProcessMonitorService = class extends Context.Tag("@dxos/functions/ProcessMonitorService")() {
-};
-var SpawnedEvent = EventType("process.spawned", {
-  schema: Schema.Void,
-  isEphemeral: false
-});
-var ExitedEvent = EventType("process.exited", {
-  schema: Schema.Struct({
-    outcome: Schema.Literal("succeeded", "failed", "terminated")
-  }),
-  isEphemeral: false
-});
-var prettyProcessTree = (tree) => {
-  if (tree.length === 0) {
-    return "";
-  }
-  const pidSet = new Set(tree.map((node) => node.pid));
-  const childrenByParent = /* @__PURE__ */ new Map();
-  const roots = [];
-  for (const node of tree) {
-    const parent = node.parentPid;
-    if (parent === null || !pidSet.has(parent)) {
-      roots.push(node);
-      continue;
-    }
-    const key2 = String(parent);
-    const siblings = childrenByParent.get(key2) ?? [];
-    siblings.push(node);
-    childrenByParent.set(key2, siblings);
-  }
-  const byPid = (a, b) => String(a.pid).localeCompare(String(b.pid));
-  roots.sort(byPid);
-  for (const siblings of childrenByParent.values()) {
-    siblings.sort(byPid);
-  }
-  const formatLabel = (node) => {
-    const idShort = String(node.pid).slice(0, 6);
-    const parts = [
-      idShort,
-      node.state
-    ];
-    if (node.params.name != null && node.params.name !== "") {
-      parts.push(node.params.name);
-    }
-    if (node.error != null) {
-      parts.push(`(${node.error})`);
-    }
-    const { inputCount, outputCount, wallTime } = node.metrics;
-    parts.push(`[in:${inputCount} out:${outputCount} wall:${Math.round(wallTime)}ms]`);
-    return parts.join(" ");
-  };
-  const lines = [];
-  const walk = (node, prefix, isLast, isRoot) => {
-    if (isRoot) {
-      lines.push(`- ${formatLabel(node)}`);
-    } else {
-      const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      lines.push(`${prefix}${branch}${formatLabel(node)}`);
-    }
-    const children = childrenByParent.get(String(node.pid)) ?? [];
-    const nextPrefix = isRoot ? "  " : `${prefix}${isLast ? "    " : "\u2502   "}`;
-    children.forEach((child, index) => {
-      walk(child, nextPrefix, index === children.length - 1, false);
-    });
-  };
-  for (const root of roots) {
-    walk(root, "", true, true);
-  }
-  return lines.join("\n");
-};
-
-// src/process/ServiceResolver.ts
-var ServiceResolver_exports = {};
-__export(ServiceResolver_exports, {
-  ServiceResolver: () => ServiceResolver,
-  compose: () => compose,
-  empty: () => empty2,
-  fromContext: () => fromContext,
-  fromRequirements: () => fromRequirements,
-  layerRequirements: () => layerRequirements,
-  make: () => make3,
-  resolve: () => resolve,
-  resolveAll: () => resolveAll,
-  succeed: () => succeed
-});
-import * as Context2 from "effect/Context";
-import * as Effect2 from "effect/Effect";
-import * as Either from "effect/Either";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-var ServiceResolverTypeId = "~@dxos/functions/ServiceResolver";
-var ServiceResolver = Context2.GenericTag("@dxos/functions/ServiceResolver");
-var resolve = Effect2.serviceFunctionEffect(ServiceResolver, (_) => _.resolve);
-var resolveAll = (tags, context) => Effect2.gen(function* () {
-  const services = yield* Effect2.forEach(tags, (tag) => resolve(tag, context).pipe(Effect2.map((service) => Context2.make(tag, service))));
-  return Context2.mergeAll(...services);
-});
-var succeed = (tag, getService) => {
-  return make3((tag1, context) => {
-    if (tag1.key !== tag.key) {
-      return Effect2.fail(new ServiceNotAvailableError(`Service not available: ${String(tag.key ?? tag)}`));
-    }
-    const service = getService(context);
-    return service;
-  });
-};
-var make3 = (resolveFn) => ({
-  [ServiceResolverTypeId]: ServiceResolverTypeId,
-  resolve: resolveFn
-});
-var fromContext = (ctx) => make3((tag, context) => Effect2.gen(function* () {
-  const service = Context2.getOption(ctx, tag);
-  if (Option.isNone(service)) {
-    return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-  }
-  return service.value;
-}));
-var fromRequirements = (...tags) => Effect2.contextWith((parentCtx) => {
-  const available = new Set(tags.map((tag) => tag.key));
-  return make3((tag, context) => Effect2.gen(function* () {
-    let result = Context2.empty();
-    if (!available.has(tag.key)) {
-      return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-    }
-    const service = Context2.getOption(parentCtx, tag);
-    if (Option.isNone(service)) {
-      return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-    }
-    return service.value;
-  }));
-});
-var layerRequirements = (...tags) => Layer.effect(ServiceResolver, fromRequirements(...tags));
-var compose = (...resolvers) => make3((tag, context) => Effect2.gen(function* () {
-  for (const resolver of resolvers) {
-    const single = yield* resolver.resolve(tag, context).pipe(Effect2.either);
-    if (Either.isRight(single)) {
-      return single.right;
-    }
-  }
-  return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-}));
-var empty2 = make3((tag, context) => {
-  return Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-});
-
-// src/process/StorageService.ts
-import * as Context3 from "effect/Context";
-import * as Effect3 from "effect/Effect";
-import * as Option2 from "effect/Option";
-import * as Pipeable from "effect/Pipeable";
-var StorageService = class extends Context3.Tag("@dxos/functions/StorageService")() {
-};
-var get = Effect3.serviceFunctionEffect(StorageService, (_) => _.get);
-var set = Effect3.serviceFunctionEffect(StorageService, (_) => _.set);
-var deleteKey = Effect3.serviceFunctionEffect(StorageService, (_) => _.delete);
-var list = Effect3.serviceFunctionEffect(StorageService, (_) => _.list);
-var clear = Effect3.serviceFunctionEffect(StorageService, (_) => _.clear);
-var key = (schema, key2) => {
-  return {
-    key: key2,
-    get: get(schema, key2),
-    set: (value2) => set(schema, key2, value2),
-    delete: () => deleteKey(key2),
-    pipe(...args) {
-      return Pipeable.pipeArguments(this, arguments);
-    }
-  };
-};
-var withDefault = (getDefault) => (key2) => {
-  return {
-    key: key2.key,
-    get: key2.get.pipe(Effect3.map(Option2.getOrElse(() => getDefault()))),
-    set: (value2) => key2.set(value2),
-    delete: () => key2.delete(),
-    pipe(...args) {
-      return Pipeable.pipeArguments(this, arguments);
-    }
-  };
-};
-
 // src/services/credentials.ts
 import * as HttpClient from "@effect/platform/HttpClient";
 import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as Context4 from "effect/Context";
-import * as Effect4 from "effect/Effect";
-import * as Layer2 from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
+import { Credential } from "@dxos/compute";
 import { Query } from "@dxos/echo";
 import { Database } from "@dxos/echo";
 import { AccessToken } from "@dxos/types";
-var CredentialsService = class _CredentialsService extends Context4.Tag("@dxos/functions/CredentialsService")() {
-  static getCredential = (query) => Effect4.gen(function* () {
-    const credentials = yield* _CredentialsService;
-    return yield* Effect4.promise(() => credentials.getCredential(query));
-  });
-  static getApiKey = (query) => Effect4.gen(function* () {
-    const credential = yield* _CredentialsService.getCredential(query);
-    if (!credential.apiKey) {
-      throw new Error(`API key not found for service: ${query.service}`);
-    }
-    return Redacted.make(credential.apiKey);
-  });
-  static configuredLayer = (credentials) => Layer2.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
-  static layerConfig = (credentials) => Layer2.effect(_CredentialsService, Effect4.gen(function* () {
-    const serviceCredentials = yield* Effect4.forEach(credentials, ({ service, apiKey }) => Effect4.gen(function* () {
-      return {
-        service,
-        apiKey: Redacted.value(yield* apiKey)
-      };
-    }));
-    return new ConfiguredCredentialsService(serviceCredentials);
-  }));
-  static layerFromDatabase = ({ caching = false } = {}) => Layer2.effect(_CredentialsService, Effect4.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;
-    };
-    return {
-      getCredential: async (query) => {
-        const credentials = await queryCredentials(query);
-        if (credentials.length === 0) {
-          throw new Error(`Credential not found for service: ${query.service}`);
-        }
-        return credentials[0];
-      },
-      queryCredentials: async (query) => {
-        return queryCredentials(query);
-      }
-    };
-  }));
-};
 var ConfiguredCredentialsService = class {
   credentials;
   constructor(credentials = []) {
@@ -395,484 +32,77 @@ var withAuthorization = (token, kind) => HttpClient.mapRequest((request) => {
   const authorization = kind ? `${kind} ${token}` : token;
   return HttpClientRequest.setHeader(request, "Authorization", authorization);
 });
-
-// src/services/event-logger.ts
-import * as Context6 from "effect/Context";
-import * as Effect6 from "effect/Effect";
-import * as Layer4 from "effect/Layer";
-import * as Schema2 from "effect/Schema";
-import { Obj as Obj2, Type } from "@dxos/echo";
-import { invariant } from "@dxos/invariant";
-import { LogLevel, log } from "@dxos/log";
-
-// src/services/tracing.ts
-import * as Context5 from "effect/Context";
-import * as Effect5 from "effect/Effect";
-import * as Layer3 from "effect/Layer";
-import { AgentStatus } from "@dxos/ai";
-import { Obj } from "@dxos/echo";
-import { ObjectId } from "@dxos/keys";
-import { Message } from "@dxos/types";
-var TracingService = class _TracingService extends Context5.Tag("@dxos/functions/TracingService")() {
-  static noop = {
-    getTraceContext: () => ({}),
-    write: () => {
-    },
-    ephemeral: () => {
-    },
-    traceInvocationStart: () => Effect5.sync(() => ({
-      invocationId: ObjectId.random(),
-      invocationTraceQueue: void 0
-    })),
-    traceInvocationEnd: () => Effect5.sync(() => {
-    })
-  };
-  static layerNoop = Layer3.succeed(_TracingService, _TracingService.noop);
-  /**
-  * Creates a TracingService layer that emits events to the parent tracing service.
-  */
-  static layerSubframe = (mapContext) => Layer3.effect(_TracingService, Effect5.gen(function* () {
-    const tracing = yield* _TracingService;
-    const context = mapContext(tracing.getTraceContext());
+var configuredCredentialsLayer = (credentials) => Layer.succeed(Credential.CredentialsService, new ConfiguredCredentialsService(credentials));
+var credentialsLayerConfig = (credentials) => Layer.effect(Credential.CredentialsService, Effect.gen(function* () {
+  const serviceCredentials = yield* Effect.forEach(credentials, ({ service, apiKey }) => Effect.gen(function* () {
     return {
-      write: (event, context2) => tracing.write(event, context2),
-      ephemeral: (event, context2) => tracing.ephemeral(event, context2),
-      getTraceContext: () => context,
-      traceInvocationStart: () => Effect5.die("Tracing invocation inside another invocation is not supported."),
-      traceInvocationEnd: () => Effect5.die("Tracing invocation inside another invocation is not supported.")
+      service,
+      apiKey: Redacted.value(yield* apiKey)
     };
   }));
-  /**
-  * Create sublayer to trace an invocation.
-  * @param data
-  * @returns
-  */
-  static layerInvocation = (data) => _TracingService.layerSubframe((context) => ({
-    ...context,
-    currentInvocation: data
-  }));
-  /**
-  * Emit the current human-readable execution status.
-  */
-  static emitStatus = Effect5.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj.make(AgentStatus, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      toolCallId: tracing.getTraceContext().toolCallId,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      ...data
-    }), tracing.getTraceContext());
-  });
-  static emitConverationMessage = Effect5.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj.make(Message.Message, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      ...data,
-      properties: {
-        [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
-        ...data.properties
-      }
-    }), tracing.getTraceContext());
-  });
-  static emitEphemeralMessage = Effect5.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.ephemeral(data, 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 = Schema2.Union(Schema2.Struct({
-  type: Schema2.Literal("begin-compute"),
-  nodeId: Schema2.String,
-  /**
-   * Names of the inputs begin computed.
-   */
-  inputs: Schema2.Array(Schema2.String)
-}), Schema2.Struct({
-  type: Schema2.Literal("end-compute"),
-  nodeId: Schema2.String,
-  /**
-   * Names of the outputs computed.
-   */
-  outputs: Schema2.Array(Schema2.String)
-}), Schema2.Struct({
-  type: Schema2.Literal("compute-input"),
-  nodeId: Schema2.String,
-  property: Schema2.String,
-  value: Schema2.Any
-}), Schema2.Struct({
-  type: Schema2.Literal("compute-output"),
-  nodeId: Schema2.String,
-  property: Schema2.String,
-  value: Schema2.Any
-}), Schema2.Struct({
-  type: Schema2.Literal("custom"),
-  nodeId: Schema2.String,
-  event: Schema2.Any
+  return new ConfiguredCredentialsService(serviceCredentials);
 }));
-var ComputeEvent = Schema2.Struct({
-  payload: ComputeEventPayload
-}).pipe(Type.object({
-  typename: "org.dxos.type.computeEvent",
-  version: "0.1.0"
-}));
-var ComputeEventLogger = class _ComputeEventLogger extends Context6.Tag("@dxos/functions/ComputeEventLogger")() {
-  static noop = {
-    log: () => {
-    },
-    nodeId: void 0
+var credentialsLayerFromDatabase = ({ caching = false } = {}) => Layer.effect(Credential.CredentialsService, Effect.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;
   };
-  /**
-  * Implements ComputeEventLogger using TracingService.
-  */
-  static layerFromTracing = Layer4.effect(_ComputeEventLogger, Effect6.gen(function* () {
-    const tracing = yield* TracingService;
-    return {
-      log: (event) => {
-        tracing.write(Obj2.make(ComputeEvent, {
-          payload: event
-        }), tracing.getTraceContext());
-      },
-      nodeId: void 0
-    };
-  }));
-};
-var logCustomEvent = (data) => Effect6.gen(function* () {
-  const logger = yield* ComputeEventLogger;
-  if (!logger.nodeId) {
-    throw new Error("logCustomEvent must be called within a node compute function");
-  }
-  logger.log({
-    type: "custom",
-    nodeId: logger.nodeId,
-    event: data
-  });
-});
-var createDefectLogger = () => Effect6.catchAll((error) => Effect6.gen(function* () {
-  log.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]: log.warn,
-    [LogLevel.VERBOSE]: log.verbose,
-    [LogLevel.DEBUG]: log.debug,
-    [LogLevel.INFO]: log.info,
-    [LogLevel.ERROR]: log.error
-  }[level];
-  invariant(logFunction, void 0, {
-    F: __dxlog_file,
-    L: 120,
-    S: void 0,
-    A: [
-      "logFunction",
-      ""
-    ]
-  });
   return {
-    log: (event) => {
-      logFunction(message, event);
+    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];
     },
-    nodeId: void 0
+    queryCredentials: async (query) => {
+      return queryCredentials(query);
+    }
   };
-};
+}));
 
 // src/services/function-invocation-service.ts
-import * as Context7 from "effect/Context";
-import * as Effect7 from "effect/Effect";
-import * as Layer5 from "effect/Layer";
-var FunctionInvocationService = class _FunctionInvocationService extends Context7.Tag("@dxos/functions/FunctionInvocationService")() {
-  static layerNotAvailable = Layer5.succeed(_FunctionInvocationService, {
-    invokeFunction: () => Effect7.die("FunctionInvocationService is not avaialble."),
-    resolveFunction: () => Effect7.die("FunctionInvocationService is not available.")
+import * as Context from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+var FunctionInvocationService = class _FunctionInvocationService extends Context.Tag("@dxos/functions/FunctionInvocationService")() {
+  static layerNotAvailable = Layer2.succeed(_FunctionInvocationService, {
+    invokeFunction: () => Effect2.die("FunctionInvocationService is not avaialble."),
+    resolveFunction: () => Effect2.die("FunctionInvocationService is not available.")
   });
-  static invokeFunction = (functionDef, input) => Effect7.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
-  static resolveFunction = (key2) => Effect7.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key2);
+  static invokeFunction = (functionDef, input) => Effect2.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+  static resolveFunction = (key) => Effect2.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key);
 };
 
 // src/services/queues.ts
-import * as Context8 from "effect/Context";
-import * as Effect8 from "effect/Effect";
-import * as Layer6 from "effect/Layer";
-import { createFeedServiceLayer } from "@dxos/echo-db";
-var QueueService = class _QueueService extends Context8.Tag("@dxos/functions/QueueService")() {
-  static notAvailable = Layer6.succeed(_QueueService, {
-    queues: {
-      get(_dxn) {
-        throw new Error("Queues not available");
-      },
-      create() {
-        throw new Error("Queues not available");
-      }
-    },
-    queue: void 0
-  });
-  static make = (queues, queue) => {
-    return {
-      queues,
-      queue
-    };
-  };
-  static layer = (queues, queue) => Layer6.succeed(_QueueService, _QueueService.make(queues, queue));
-  /**
-  * Gets a queue by its DXN.
-  */
-  static getQueue = (dxn) => _QueueService.pipe(Effect8.map(({ queues }) => queues.get(dxn)));
-  /**
-  * Creates a new queue.
-  */
-  static createQueue = (options) => _QueueService.pipe(Effect8.map(({ queues }) => queues.create(options)));
-  static append = (queue, objects) => Effect8.promise(() => queue.append(objects));
-};
-var ContextQueueService = class _ContextQueueService extends Context8.Tag("@dxos/functions/ContextQueueService")() {
-  static layer = (queue) => Layer6.succeed(_ContextQueueService, {
-    queue
-  });
-};
-var feedServiceFromQueueServiceLayer = Layer6.unwrapEffect(Effect8.gen(function* () {
-  const { queues } = yield* QueueService;
-  return createFeedServiceLayer(queues);
-}));
-
-// src/types/Script.ts
-var Script_exports = {};
-__export(Script_exports, {
-  Script: () => Script,
-  make: () => make5
-});
-import * as Schema3 from "effect/Schema";
-import { Annotation, Obj as Obj3, Ref, Type as Type2 } from "@dxos/echo";
-import { FormInputAnnotation } from "@dxos/echo/internal";
-import { Text } from "@dxos/schema";
-var Script = Schema3.Struct({
-  name: Schema3.String.pipe(Schema3.optional),
-  description: Schema3.String.pipe(Schema3.optional),
-  // TODO(burdon): Change to hash of deployed content.
-  // Whether source has changed since last deploy.
-  changed: Schema3.Boolean.pipe(FormInputAnnotation.set(false), Schema3.optional),
-  source: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false))
-}).pipe(Type2.object({
-  typename: "org.dxos.type.script",
-  version: "0.1.0"
-}), Annotation.LabelAnnotation.set([
-  "name"
-]), Annotation.IconAnnotation.set({
-  icon: "ph--code--regular",
-  hue: "sky"
-}));
-var make5 = ({ source = "", ...props } = {}) => Obj3.make(Script, {
-  ...props,
-  source: Ref.make(Text.make({
-    content: source
-  }))
-});
-
-// src/types/Trigger.ts
-var Trigger_exports = {};
-__export(Trigger_exports, {
-  EmailSpec: () => EmailSpec,
-  Kinds: () => Kinds,
-  QueueSpec: () => QueueSpec,
-  Spec: () => Spec,
-  SubscriptionSpec: () => SubscriptionSpec,
-  TimerSpec: () => TimerSpec,
-  Trigger: () => Trigger,
-  WebhookSpec: () => WebhookSpec,
-  make: () => make6
-});
-import * as Schema4 from "effect/Schema";
-import * as SchemaAST from "effect/SchemaAST";
-import { Annotation as Annotation2, Obj as Obj4, QueryAST, Ref as Ref2, Type as Type3 } from "@dxos/echo";
-import { OptionsAnnotationId, SystemTypeAnnotation } from "@dxos/echo/internal";
-import { DXN } from "@dxos/keys";
-var Kinds = [
-  "email",
-  "queue",
-  "subscription",
-  "timer",
-  "webhook"
-];
-var kindLiteralAnnotations = {
-  title: "Kind"
-};
-var EmailSpec = Schema4.Struct({
-  kind: Schema4.Literal("email").annotations(kindLiteralAnnotations)
-});
-var QueueSpec = Schema4.Struct({
-  kind: Schema4.Literal("queue").annotations(kindLiteralAnnotations),
-  // TODO(dmaretskyi): Rename to `feed` and change to a reference.
-  queue: DXN.Schema
-});
-var SubscriptionSpec = Schema4.Struct({
-  kind: Schema4.Literal("subscription").annotations(kindLiteralAnnotations),
-  query: Schema4.Struct({
-    raw: Schema4.optional(Schema4.String.annotations({
-      title: "Query"
-    })),
-    ast: QueryAST.Query
-  }),
-  options: Schema4.optional(Schema4.Struct({
-    // Watch changes to object (not just creation).
-    deep: Schema4.optional(Schema4.Boolean.annotations({
-      title: "Nested"
-    })),
-    // Debounce changes (delay in ms).
-    delay: Schema4.optional(Schema4.Number.annotations({
-      title: "Delay"
-    }))
-  }).annotations({
-    title: "Options"
-  }))
-});
-var TimerSpec = Schema4.Struct({
-  kind: Schema4.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema4.String.annotations({
-    title: "Cron",
-    [SchemaAST.ExamplesAnnotationId]: [
-      "0 0 * * *"
-    ]
-  })
-});
-var WebhookSpec = Schema4.Struct({
-  kind: Schema4.Literal("webhook").annotations(kindLiteralAnnotations),
-  method: Schema4.optional(Schema4.String.annotations({
-    title: "Method",
-    [OptionsAnnotationId]: [
-      "GET",
-      "POST"
-    ]
-  })),
-  port: Schema4.optional(Schema4.Number.annotations({
-    title: "Port"
-  }))
-});
-var Spec = Schema4.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
-  title: "Trigger"
-});
-var TriggerSchema = Schema4.Struct({
-  /**
-  * Function or workflow to invoke.
-  */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema4.optional(Ref2.Ref(Obj4.Unknown).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: Schema4.optional(Schema4.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: Schema4.optional(Schema4.Boolean.annotations({
-    title: "Enabled"
-  })),
-  spec: Schema4.optional(Spec),
-  concurrency: Schema4.optional(Schema4.Number.annotations({
-    title: "Concurrency",
-    default: 1,
-    description: "Maximum number of concurrent invocations of the trigger. For Feed triggers, this will process Feed items in parallel."
-  })),
-  /**
-  * Passed as the input data to the function.
-  * Must match the function's input schema.
-  *
-  * @example
-  * {
-  *   item: '{{event.item}}',
-  *   instructions: 'Summarize and perform entity-extraction'
-  *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
-  * }
-  */
-  input: Schema4.optional(Schema4.Record({
-    key: Schema4.String,
-    value: Schema4.Any
-  }))
-}).pipe(Type3.object({
-  typename: "org.dxos.type.trigger",
-  version: "0.1.0"
-}), Annotation2.IconAnnotation.set({
-  icon: "ph--lightning--regular",
-  hue: "yellow"
-}), SystemTypeAnnotation.set(true));
-var Trigger = TriggerSchema;
-var make6 = (props) => Obj4.make(Trigger, props);
+import { ContextQueueService, QueueService, feedServiceFromQueueServiceLayer } from "@dxos/echo-db";
 
-// src/types/TriggerEvent.ts
-var TriggerEvent_exports = {};
-__export(TriggerEvent_exports, {
-  EmailEvent: () => EmailEvent,
-  QueueEvent: () => QueueEvent,
-  SubscriptionEvent: () => SubscriptionEvent,
-  TimerEvent: () => TimerEvent,
-  TriggerEvent: () => TriggerEvent,
-  WebhookEvent: () => WebhookEvent
-});
-import * as Schema5 from "effect/Schema";
-import { DXN as DXN2, Obj as Obj5, Ref as Ref3 } from "@dxos/echo";
-var EmailEvent = Schema5.Struct({
-  from: Schema5.String,
-  to: Schema5.String,
-  subject: Schema5.String,
-  created: Schema5.String,
-  body: Schema5.String
-});
-var QueueEvent = Schema5.Struct({
-  queue: DXN2.Schema,
-  item: Schema5.Any,
-  cursor: Schema5.String
-});
-var SubscriptionEvent = Schema5.Struct({
-  /**
-  * Type of the mutation.
-  */
-  // TODO(dmaretskyi): Specify enum.
-  type: Schema5.String,
-  /**
-  * Reference to the object that was changed or created.
-  */
-  subject: Ref3.Ref(Obj5.Unknown),
-  /**
-  * @deprecated
-  */
-  changedObjectId: Schema5.optional(Schema5.String)
-});
-var TimerEvent = Schema5.Struct({
-  tick: Schema5.Number
-});
-var WebhookEvent = Schema5.Struct({
-  url: Schema5.String,
-  method: Schema5.Literal("GET", "POST"),
-  headers: Schema5.Record({
-    key: Schema5.String,
-    value: Schema5.String
-  }),
-  bodyText: Schema5.String
-});
-var TriggerEvent = Schema5.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
+// src/services/tracing.ts
+var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
 
 // src/types/url.ts
 var FUNCTIONS_META_KEY = "org.dxos.service.function";
 var FUNCTIONS_PRESET_META_KEY = "org.dxos.service.function-preset";
 var getUserFunctionIdInMetadata = (meta) => {
-  return meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY)?.id;
+  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
 };
 var setUserFunctionIdInMetadata = (meta, functionId) => {
-  const key2 = meta.keys.find((key3) => key3.source === FUNCTIONS_META_KEY);
-  if (key2) {
-    if (key2.id !== functionId) {
+  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionId) {
       throw new Error("Metadata mismatch");
     }
   } else {
@@ -885,40 +115,40 @@ var setUserFunctionIdInMetadata = (meta, functionId) => {
 
 // src/protocol/protocol.ts
 import * as AnthropicClient from "@effect/ai-anthropic/AnthropicClient";
-import * as Effect10 from "effect/Effect";
-import * as Layer8 from "effect/Layer";
-import * as Schema6 from "effect/Schema";
-import * as SchemaAST2 from "effect/SchemaAST";
+import * as Effect4 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
 import { AiModelResolver, AiService } from "@dxos/ai";
 import { AnthropicResolver } from "@dxos/ai/resolvers";
+import { FunctionError, InvalidOperationInputError, InvalidOperationOutputError, Operation, Trace } from "@dxos/compute";
 import { LifecycleState, Resource } from "@dxos/context";
-import { Database as Database2, Feed, JsonSchema, Ref as Ref4 } from "@dxos/echo";
-import { EchoClient, createFeedServiceLayer as createFeedServiceLayer2 } from "@dxos/echo-db";
+import { Database as Database2, Feed, JsonSchema, Ref } from "@dxos/echo";
+import { EchoClient, createFeedServiceLayer } from "@dxos/echo-db";
 import { refFromEncodedReference } from "@dxos/echo/internal";
 import { runAndForwardErrors } from "@dxos/effect";
-import { assertState, failedInvariant, invariant as invariant2 } from "@dxos/invariant";
+import { assertState, failedInvariant, invariant } from "@dxos/invariant";
 import { PublicKey } from "@dxos/keys";
-import { Operation } from "@dxos/operation";
 
 // 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 Effect9 from "effect/Effect";
+import * as Effect3 from "effect/Effect";
 import * as FiberRef from "effect/FiberRef";
-import * as Layer7 from "effect/Layer";
+import * as Layer3 from "effect/Layer";
 import * as Stream from "effect/Stream";
-import { log as log2 } from "@dxos/log";
+import { log } 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 __dxlog_file = "/__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) => Effect9.tryPromise({
+    const send = (body) => Effect3.tryPromise({
       try: () => service.fetch(new Request(url, {
         ...options,
         method: request.method,
@@ -926,21 +156,16 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
         body
       })),
       catch: (cause) => {
-        log2.error("Failed to fetch", {
+        log.error("Failed to fetch", {
           errorSerialized: ErrorCodec.encode(cause)
-        }, {
-          F: __dxlog_file2,
-          L: 43,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 30, S: this });
         return new HttpClientError.RequestError({
           request,
           reason: "Transport",
           cause
         });
       }
-    }).pipe(Effect9.map((response) => HttpClientResponse.fromWeb(request, response)));
+    }).pipe(Effect3.map((response) => HttpClientResponse.fromWeb(request, response)));
     switch (request.body._tag) {
       case "Raw":
       case "Uint8Array":
@@ -948,14 +173,15 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
       case "FormData":
         return send(request.body.formData);
       case "Stream":
-        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect9.flatMap(send));
+        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect3.flatMap(send));
     }
     return send(void 0);
   });
-  static layer = (service) => Layer7.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
+  static layer = (service) => Layer3.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
 };
 
 // src/protocol/protocol.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/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.");
@@ -995,7 +221,7 @@ function _ts_dispose_resources(env) {
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
   };
   return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
-    function fail2(e) {
+    function fail(e) {
       env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
       env2.hasError = true;
     }
@@ -1007,12 +233,12 @@ function _ts_dispose_resources(env) {
           if (r.dispose) {
             var result = r.dispose.call(r.value);
             if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-              fail2(e);
+              fail(e);
               return next();
             });
           } else s |= 1;
         } catch (e) {
-          fail2(e);
+          fail(e);
         }
       }
       if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
@@ -1021,7 +247,6 @@ function _ts_dispose_resources(env) {
     return next();
   })(env);
 }
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
 var wrapFunctionHandler = (func) => {
   if (!Operation.isOperationWithHandler(func)) {
     throw new TypeError("Expected operation with handler");
@@ -1049,36 +274,39 @@ var wrapFunctionHandler = (func) => {
           hasError: false
         };
         try {
-          if (!SchemaAST2.isAnyKeyword(func.input.ast)) {
+          if (!SchemaAST.isAnyKeyword(func.input.ast)) {
             try {
-              Schema6.validateSync(func.input)(data);
+              Schema.validateSync(func.input, {
+                onExcessProperty: "error"
+              })(data);
             } catch (error) {
-              throw new FunctionError({
-                message: "Invalid input schema",
+              throw new InvalidOperationInputError({
+                message: `Operation input did not match schema (${func.meta.key}): ${error.message}`,
                 cause: error
               });
             }
           }
           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: 73,
-              S: void 0,
-              A: [
-                "funcContext.db",
-                "'Database is required for functions with types'"
-              ]
-            });
+            invariant(funcContext.db, "Database is required for functions with types", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 130, S: void 0, A: ["funcContext.db", "'Database is required for functions with types'"] });
             await funcContext.db.graph.schemaRegistry.register(func.types);
           }
-          const dataWithDecodedRefs = funcContext.db && !SchemaAST2.isAnyKeyword(func.input.ast) ? decodeRefsFromSchema(func.input.ast, data, funcContext.db) : data;
+          const dataWithDecodedRefs = funcContext.db && !SchemaAST.isAnyKeyword(func.input.ast) ? decodeRefsFromSchema(func.input.ast, data, funcContext.db) : data;
           let result = await func.handler(dataWithDecodedRefs);
-          if (Effect10.isEffect(result)) {
-            result = await runAndForwardErrors(result.pipe(Effect10.orDie, Effect10.provide(funcContext.createLayer())));
+          if (Effect4.isEffect(result)) {
+            result = await runAndForwardErrors(result.pipe(Effect4.orDie, Effect4.provide(funcContext.createLayer())));
           }
-          if (func.output && !SchemaAST2.isAnyKeyword(func.output.ast)) {
-            Schema6.validateSync(func.output)(result);
+          if (func.output && !SchemaAST.isAnyKeyword(func.output.ast)) {
+            try {
+              Schema.validateSync(func.output, {
+                onExcessProperty: "error"
+              })(result);
+            } catch (error) {
+              throw new InvalidOperationOutputError({
+                message: `Operation output did not match schema (${func.meta.key}): ${error.message}`,
+                cause: error
+              });
+            }
           }
           return result;
         } catch (e) {
@@ -1130,39 +358,47 @@ var FunctionContext = class extends Resource {
     assertState(this._lifecycleState === LifecycleState.OPEN, "FunctionContext is not open");
     const dbLayer = this.db ? Database2.layer(this.db) : Database2.notAvailable;
     const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
-    const feedLayer = this.queues ? createFeedServiceLayer2(this.queues) : Feed.notAvailable;
-    const credentials = dbLayer ? CredentialsService.layerFromDatabase({
+    const feedLayer = this.queues ? createFeedServiceLayer(this.queues) : Feed.notAvailable;
+    const credentials = dbLayer ? credentialsLayerFromDatabase({
       caching: true
-    }).pipe(Layer8.provide(dbLayer)) : CredentialsService.configuredLayer([]);
+    }).pipe(Layer4.provide(dbLayer)) : configuredCredentialsLayer([]);
     const functionInvocationService = MockedFunctionInvocationService;
-    const tracing = TracingService.layerNoop;
-    const aiLayer = this.context.services.functionsAiService ? AiModelResolver.AiModelResolver.buildAiService.pipe(Layer8.provide(AnthropicResolver.make().pipe(Layer8.provide(AnthropicClient.layer({
+    const operationServiceLayer = MockedOperationServiceLayer;
+    const aiLayer = this.context.services.functionsAiService ? AiModelResolver.AiModelResolver.buildAiService.pipe(Layer4.provide(AnthropicResolver.make().pipe(Layer4.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(Layer8.provide(FunctionsAiHttpClient.layer(this.context.services.functionsAiService))))))) : AiService.notAvailable;
-    return Layer8.mergeAll(
+    }).pipe(Layer4.provide(FunctionsAiHttpClient.layer(this.context.services.functionsAiService))))))) : AiService.notAvailable;
+    return Layer4.mergeAll(
       dbLayer,
       queuesLayer,
       feedLayer,
       credentials,
       functionInvocationService,
+      operationServiceLayer,
       aiLayer,
-      tracing,
-      writerLayerNoop
+      // TODO(dmaretskyi): Forward trace events.
+      Trace.writerLayerNoop
     );
   }
 };
-var MockedFunctionInvocationService = Layer8.succeed(FunctionInvocationService, {
-  invokeFunction: () => Effect10.die("Calling functions from functions is not implemented yet."),
-  resolveFunction: () => Effect10.die("Not implemented.")
+var MockedFunctionInvocationService = Layer4.succeed(FunctionInvocationService, {
+  invokeFunction: () => Effect4.die("Calling functions from functions is not implemented yet."),
+  resolveFunction: () => Effect4.die("Not implemented.")
+});
+var MockedOperationServiceLayer = Layer4.succeed(Operation.Service, {
+  invoke: () => Effect4.die("Calling operations from functions is not implemented yet."),
+  schedule: () => Effect4.die("Not implemented."),
+  invokePromise: async () => ({
+    error: new Error("Not implemented")
+  })
 });
 var decodeRefsFromSchema = (ast, value2, db) => {
   if (value2 == null) {
     return value2;
   }
-  const encoded = SchemaAST2.encodedBoundAST(ast);
-  if (Ref4.isRefType(encoded)) {
-    if (Ref4.isRef(value2)) {
+  const encoded = SchemaAST.encodedBoundAST(ast);
+  if (Ref.isRefType(encoded)) {
+    if (Ref.isRef(value2)) {
       return value2;
     }
     if (typeof value2 === "object" && value2 !== null && typeof value2["/"] === "string") {
@@ -1183,10 +419,10 @@ var decodeRefsFromSchema = (ast, value2, db) => {
       const result = {
         ...value2
       };
-      for (const prop of SchemaAST2.getPropertySignatures(encoded)) {
-        const key2 = prop.name.toString();
-        if (key2 in result) {
-          result[key2] = decodeRefsFromSchema(prop.type, result[key2], db);
+      for (const prop of SchemaAST.getPropertySignatures(encoded)) {
+        const key = prop.name.toString();
+        if (key in result) {
+          result[key] = decodeRefsFromSchema(prop.type, result[key], db);
         }
       }
       return result;
@@ -1202,7 +438,7 @@ var decodeRefsFromSchema = (ast, value2, db) => {
       return value2;
     }
     case "Union": {
-      const nonUndefined = encoded.types.filter((t) => !SchemaAST2.isUndefinedKeyword(t));
+      const nonUndefined = encoded.types.filter((t) => !SchemaAST.isUndefinedKeyword(t));
       if (nonUndefined.length === 1) {
         return decodeRefsFromSchema(nonUndefined[0], value2, db);
       }
@@ -1220,47 +456,20 @@ var decodeRefsFromSchema = (ast, value2, db) => {
   }
 };
 export {
-  ComputeEvent,
-  ComputeEventLogger,
-  ComputeEventPayload,
   ConfiguredCredentialsService,
   ContextQueueService,
-  CredentialsService,
-  ExampleHandlers,
   FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
-  Fibonacci,
-  FunctionError,
   FunctionInvocationService,
-  FunctionNotFoundError,
   MESSAGE_PROPERTY_TOOL_CALL_ID,
-  Process_exports as Process,
   QueueService,
-  Reply,
-  Script_exports as Script,
-  ServiceNotAvailableError,
-  ServiceResolver_exports as ServiceResolver,
-  Sleep,
-  StorageService,
-  Trace_exports as Trace,
-  TracingService,
-  Trigger_exports as Trigger,
-  TriggerEvent_exports as TriggerEvent,
-  TriggerStateNotFoundError,
-  clear,
-  createDefectLogger,
-  createEventLogger,
-  deleteKey,
+  configuredCredentialsLayer,
+  credentialsLayerConfig,
+  credentialsLayerFromDatabase,
   feedServiceFromQueueServiceLayer,
-  get,
   getUserFunctionIdInMetadata,
-  key,
-  list,
-  logCustomEvent,
-  set,
   setUserFunctionIdInMetadata,
   withAuthorization,
-  withDefault,
   wrapFunctionHandler
 };
 //# sourceMappingURL=index.mjs.map