@dxos/functions 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,1266 @@
+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 Redacted from "effect/Redacted";
+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 = []) {
+    this.credentials = credentials;
+  }
+  addCredentials(credentials) {
+    this.credentials.push(...credentials);
+    return this;
+  }
+  async queryCredentials(query) {
+    return this.credentials.filter((credential) => credential.service === query.service);
+  }
+  async getCredential(query) {
+    const credential = this.credentials.find((credential2) => credential2.service === query.service);
+    if (!credential) {
+      throw new Error(`Credential not found for service: ${query.service}`);
+    }
+    return credential;
+  }
+};
+var withAuthorization = (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());
+    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.")
+    };
+  }));
+  /**
+  * 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
+}));
+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
+  };
+  /**
+  * 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);
+    },
+    nodeId: void 0
+  };
+};
+
+// 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.")
+  });
+  static invokeFunction = (functionDef, input) => Effect7.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+  static resolveFunction = (key2) => Effect7.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key2);
+};
+
+// 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);
+
+// 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/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;
+};
+var setUserFunctionIdInMetadata = (meta, functionId) => {
+  const key2 = meta.keys.find((key3) => key3.source === FUNCTIONS_META_KEY);
+  if (key2) {
+    if (key2.id !== functionId) {
+      throw new Error("Metadata mismatch");
+    }
+  } else {
+    meta.keys.push({
+      source: FUNCTIONS_META_KEY,
+      id: 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 { AiModelResolver, AiService } from "@dxos/ai";
+import { AnthropicResolver } from "@dxos/ai/resolvers";
+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 { refFromEncodedReference } from "@dxos/echo/internal";
+import { runAndForwardErrors } from "@dxos/effect";
+import { assertState, failedInvariant, invariant as invariant2 } 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 FiberRef from "effect/FiberRef";
+import * as Layer7 from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { log as log2 } 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) => Effect9.tryPromise({
+      try: () => service.fetch(new Request(url, {
+        ...options,
+        method: request.method,
+        headers,
+        body
+      })),
+      catch: (cause) => {
+        log2.error("Failed to fetch", {
+          errorSerialized: ErrorCodec.encode(cause)
+        }, {
+          F: __dxlog_file2,
+          L: 43,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return new HttpClientError.RequestError({
+          request,
+          reason: "Transport",
+          cause
+        });
+      }
+    }).pipe(Effect9.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(Effect9.flatMap(send));
+    }
+    return send(void 0);
+  });
+  static layer = (service) => Layer7.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];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value2[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    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
+    });
+  } 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 fail2(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) {
+              fail2(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail2(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    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");
+  }
+  const serviceTags = func.services.map((service) => service.key);
+  return {
+    meta: {
+      key: func.meta.key,
+      name: func.meta.name,
+      description: func.meta.description,
+      inputSchema: JsonSchema.toJsonSchema(func.input),
+      outputSchema: func.output === void 0 ? void 0 : JsonSchema.toJsonSchema(func.output),
+      services: func.services.map((service) => service.key)
+    },
+    handler: async ({ data, context }) => {
+      if ((serviceTags.includes(Database2.Service.key) || serviceTags.includes(QueueService.key) || serviceTags.includes(Feed.FeedService.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.input.ast)) {
+            try {
+              Schema6.validateSync(func.input)(data);
+            } catch (error) {
+              throw new FunctionError({
+                message: "Invalid input schema",
+                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'"
+              ]
+            });
+            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;
+          let result = await func.handler(dataWithDecodedRefs);
+          if (Effect10.isEffect(result)) {
+            result = await runAndForwardErrors(result.pipe(Effect10.orDie, Effect10.provide(funcContext.createLayer())));
+          }
+          if (func.output && !SchemaAST2.isAnyKeyword(func.output.ast)) {
+            Schema6.validateSync(func.output)(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;
+      }
+    }
+  };
+};
+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
+      });
+    }
+  }
+  async _open() {
+    await this.client?.open();
+    this.db = this.client && this.context.spaceId ? this.client.constructDatabase({
+      spaceId: this.context.spaceId ?? failedInvariant(),
+      spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant("spaceKey missing in context")),
+      reactiveSchemaQuery: false,
+      preloadSchemaOnOpen: false
+    }) : void 0;
+    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant("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.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({
+      caching: true
+    }).pipe(Layer8.provide(dbLayer)) : CredentialsService.configuredLayer([]);
+    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({
+      // 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(
+      dbLayer,
+      queuesLayer,
+      feedLayer,
+      credentials,
+      functionInvocationService,
+      aiLayer,
+      tracing,
+      writerLayerNoop
+    );
+  }
+};
+var MockedFunctionInvocationService = Layer8.succeed(FunctionInvocationService, {
+  invokeFunction: () => Effect10.die("Calling functions from functions is not implemented yet."),
+  resolveFunction: () => Effect10.die("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)) {
+      return value2;
+    }
+    if (typeof value2 === "object" && value2 !== null && typeof value2["/"] === "string") {
+      const resolver = db.graph.createRefResolver({
+        context: {
+          space: db.spaceId
+        }
+      });
+      return refFromEncodedReference(value2, resolver);
+    }
+    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 key2 = prop.name.toString();
+        if (key2 in result) {
+          result[key2] = decodeRefsFromSchema(prop.type, result[key2], db);
+        }
+      }
+      return result;
+    }
+    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;
+    }
+  }
+};
+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,
+  feedServiceFromQueueServiceLayer,
+  get,
+  getUserFunctionIdInMetadata,
+  key,
+  list,
+  logCustomEvent,
+  set,
+  setUserFunctionIdInMetadata,
+  withAuthorization,
+  withDefault,
+  wrapFunctionHandler
+};
+//# sourceMappingURL=index.mjs.map