@dxos/compute 0.8.4-main.fd6878d → 0.9.0

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,1183 @@
+import {
+  StorageService_exports,
+  key,
+  withDefault
+} from "./chunk-XEVFBI6S.mjs";
+import {
+  FunctionError,
+  FunctionNotFoundError,
+  FunctionsAiMemoizationMissError,
+  FunctionsAiUpstreamError,
+  InvalidOperationInputError,
+  InvalidOperationOutputError,
+  InvokerNotInitializedError,
+  NoHandlerError,
+  OperationHandlerProvider,
+  OperationHandlerSet_exports,
+  ServiceNotAvailableError,
+  TriggerStateNotFoundError,
+  getHandler,
+  getHandlerByKey
+} from "./chunk-Z3Y7FQGN.mjs";
+import {
+  Operation_exports,
+  PersistentOperation,
+  deserialize,
+  invoke,
+  isIdempotent
+} from "./chunk-QZS4G6PE.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Blueprint.ts
+var Blueprint_exports = {};
+__export(Blueprint_exports, {
+  Blueprint: () => Blueprint,
+  Blueprint_v0_1_0: () => Blueprint_v0_1_0,
+  NotFoundError: () => NotFoundError,
+  getKey: () => getKey,
+  getVersion: () => getVersion,
+  make: () => make2,
+  migrations: () => migrations,
+  registryURI: () => registryURI,
+  resolve: () => resolve,
+  toolDefinitions: () => toolDefinitions,
+  upsert: () => upsert
+});
+import * as Effect2 from "effect/Effect";
+import * as Schema3 from "effect/Schema";
+import { ToolId } from "@dxos/ai";
+import { DXN as DXN2, Annotation, Database as Database2, Filter as Filter2, Migration, Obj, Registry as Registry2, Type, URI } from "@dxos/echo";
+import { BaseError } from "@dxos/errors";
+
+// src/McpServer.ts
+var McpServer_exports = {};
+__export(McpServer_exports, {
+  McpServer: () => McpServer
+});
+import * as Schema from "effect/Schema";
+var McpServer = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional).annotations({
+    description: "Human-readable name of the MCP server"
+  }),
+  url: Schema.String.annotations({
+    description: "URL of the MCP server"
+  }),
+  /**
+  * Transport protocol. Prefer `'http'` (Streamable HTTP) for new servers; `'sse'` is
+  * kept for compatibility with servers that haven't migrated and is deprecated per
+  * the MCP SDK. Clients support both during the migration period.
+  */
+  protocol: Schema.Union(Schema.Literal("http"), Schema.Literal("sse")).annotations({
+    description: 'Transport protocol of the MCP server (prefer "http"; "sse" deprecated)'
+  }),
+  /**
+  * Optional API key sent with requests.
+  * Persisted in plaintext when stored on a space-replicated ECHO object — see the
+  * `@dxos/assistant-toolkit` `McpServer` type for security implications.
+  */
+  apiKey: Schema.optional(Schema.String).annotations({
+    description: "Optional API key sent with requests"
+  })
+});
+
+// src/Template.ts
+var Template_exports = {};
+__export(Template_exports, {
+  Input: () => Input,
+  InputKind: () => InputKind,
+  Template: () => Template,
+  make: () => make,
+  process: () => process,
+  processTemplate: () => processTemplate
+});
+import * as Effect from "effect/Effect";
+import * as Schema2 from "effect/Schema";
+import { Database, DXN, Filter, Ref, Registry } from "@dxos/echo";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { Text } from "@dxos/schema";
+import Handlebars from "@dxos/vendor-kbn-handlebars";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/compute/src/Template.ts";
+var InputKind = Schema2.Literal("value", "operation");
+var Input = Schema2.Struct({
+  name: Schema2.String,
+  kind: InputKind,
+  default: Schema2.optional(Schema2.Any),
+  /**
+  * Operation key invoked when `kind === 'operation'`. The referenced operation must accept void input —
+  * template inputs have no mechanism for passing arguments.
+  */
+  operation: Schema2.optional(Schema2.String)
+});
+var Template = Schema2.Struct({
+  source: Ref.Ref(Text.Text).annotations({
+    description: "Markdown + Handlebars template."
+  }),
+  /**
+  * NOTE: We use an array rather than map so that updating variable names in the template doesn't disconnect existing inputs.
+  */
+  inputs: Schema2.optional(Schema2.Array(Input))
+});
+var make = ({ id, source, inputs = [] } = {}) => ({
+  source: Ref.make(Text.make({
+    id,
+    content: source
+  })),
+  inputs
+});
+var process = (source, variables = {}) => {
+  assertArgument(typeof source === "string", "source");
+  let section = 0;
+  const handlebars = Handlebars.create();
+  handlebars.registerHelper("section", () => String(++section));
+  const template = handlebars.compileAST(source.trim());
+  const output = template(variables);
+  return output.trim().replace(/(\n\s*){3,}/g, "\n\n");
+};
+var processTemplate = (template) => Effect.gen(function* () {
+  const entries = yield* Effect.forEach(template.inputs ?? [], (input) => Effect.gen(function* () {
+    switch (input.kind) {
+      case "value": {
+        return [
+          input.name,
+          input.default
+        ];
+      }
+      case "operation": {
+        invariant(input.operation, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 69, S: this, A: ["input.operation", ""] });
+        const key2 = DXN.isDXN(input.operation) ? input.operation : `dxn:${input.operation}`;
+        const results = yield* Registry.runQuery(Filter.and(Filter.type(PersistentOperation), Filter.key(key2)));
+        if (results.length === 0) {
+          return yield* Effect.fail(new FunctionNotFoundError(input.operation));
+        }
+        const fn = deserialize(results[0]);
+        const result = yield* invoke(fn, void 0).pipe(Effect.orDie);
+        return [
+          input.name,
+          result
+        ];
+      }
+      default: {
+        return yield* Effect.dieMessage(`Unsupported input kind: ${input.kind}`);
+      }
+    }
+  }));
+  const variables = Object.fromEntries(entries);
+  log("processTemplate", {
+    variables
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 91, S: this });
+  return process((yield* Database.load(template.source)).content, variables);
+});
+
+// src/Blueprint.ts
+var Blueprint = Schema3.Struct({
+  /**
+  * Human-readable name of the blueprint.
+  */
+  name: Schema3.String.annotations({
+    description: "Human-readable name of the blueprint"
+  }),
+  /**
+  * Description of the blueprint's purpose and functionality.
+  */
+  description: Schema3.optional(Schema3.String).annotations({
+    description: "Description of the blueprint's purpose and functionality"
+  }),
+  /**
+  * Instructions that guide the AI assistant's behavior and responses.
+  * These are system prompts or guidelines that the AI should follow.
+  */
+  instructions: Template.annotations({
+    description: "Instructions that guide the AI assistant's behavior and responses"
+  }),
+  /**
+  * Array of tools that the AI assistant can use when this blueprint is active.
+  */
+  tools: Schema3.Array(ToolId).annotations({
+    description: "Array of tools that the AI assistant can use when this blueprint is active"
+  }),
+  /**
+  * Whether an agent is allowed to auto-enable this blueprint in a conversation.
+  */
+  agentCanEnable: Schema3.optional(Schema3.Boolean).annotations({
+    description: "Whether an agent is allowed to auto-enable this blueprint in a conversation."
+  }),
+  /**
+  * Array of MCP servers that the AI assistant can use when this blueprint is active.
+  */
+  mcpServers: Schema3.optional(Schema3.Array(McpServer))
+}).pipe(Annotation.LabelAnnotation.set([
+  "name"
+]), Annotation.IconAnnotation.set({
+  icon: "ph--blueprint--regular",
+  hue: "sky"
+}), Type.makeObject(DXN2.make("org.dxos.type.blueprint", "0.2.0")));
+var make2 = ({ key: key2, version, tools = [], instructions = make(), ...props }) => Obj.make(Blueprint, {
+  [Obj.Meta]: {
+    key: key2,
+    version
+  },
+  tools,
+  instructions,
+  ...props
+});
+var getKey = (blueprint) => {
+  const key2 = Obj.getMeta(blueprint).key;
+  if (key2 === void 0) {
+    throw new Error("Blueprint is missing the meta key.");
+  }
+  return key2;
+};
+var getVersion = (blueprint) => Obj.getMeta(blueprint).version;
+var toolDefinitions = ({ tools = [], operations = [] }) => [
+  ...operations.map((op) => ToolId.make(DXN2.getName(op.meta.key))),
+  ...tools.map((tool) => ToolId.make(tool))
+];
+var registryURI = (key2) => DXN2.tryMake(`dxn:${key2}`) ?? URI.make(key2);
+var resolve = (key2) => Effect2.gen(function* () {
+  const results = yield* Registry2.runQuery(Filter2.and(Filter2.type(Blueprint), Filter2.key(key2)));
+  const blueprint = results[0];
+  if (!blueprint) {
+    return yield* Effect2.fail(new NotFoundError({
+      context: {
+        key: key2
+      }
+    }));
+  }
+  return blueprint;
+});
+var upsert = (key2) => Effect2.gen(function* () {
+  const local = yield* Database2.query(Filter2.and(Filter2.type(Blueprint), Filter2.key(key2))).run;
+  if (local.length > 0) {
+    return local[0];
+  }
+  return yield* Database2.add(Obj.clone(yield* resolve(key2), {
+    deep: true
+  }));
+});
+var NotFoundError = class extends BaseError.extend("BlueprintNotFound", "Blueprint not found") {
+};
+var Blueprint_v0_1_0 = Schema3.Struct({
+  /**
+  * Global registry ID.
+  * NOTE: The `key` property refers to the original registry entry.
+  */
+  key: Schema3.String.annotations({
+    description: "Unique registration key for the blueprint"
+  }),
+  name: Schema3.String.annotations({
+    description: "Human-readable name of the blueprint"
+  }),
+  description: Schema3.optional(Schema3.String),
+  instructions: Template,
+  tools: Schema3.Array(ToolId),
+  agentCanEnable: Schema3.optional(Schema3.Boolean),
+  mcpServers: Schema3.optional(Schema3.Array(McpServer))
+}).pipe(Type.makeObject(DXN2.make("org.dxos.type.blueprint", "0.1.0")));
+var _migration = Migration.define({
+  from: Blueprint_v0_1_0,
+  to: Blueprint,
+  transform: async (from) => ({
+    [Obj.Meta]: {
+      key: from.key,
+      version: "0.1.0"
+    },
+    name: from.name,
+    description: from.description,
+    instructions: from.instructions,
+    tools: from.tools,
+    agentCanEnable: from.agentCanEnable,
+    mcpServers: from.mcpServers
+  })
+});
+var migrations = [
+  _migration
+];
+
+// src/Credential.ts
+var Credential_exports = {};
+__export(Credential_exports, {
+  CredentialsService: () => CredentialsService
+});
+import * as Context from "effect/Context";
+import * as Effect3 from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/functions/CredentialsService")() {
+  static getCredential = (query) => Effect3.gen(function* () {
+    const credentials = yield* _CredentialsService;
+    return yield* Effect3.promise(() => credentials.getCredential(query));
+  });
+  static getApiKey = (query) => Effect3.gen(function* () {
+    const credential = yield* _CredentialsService.getCredential(query);
+    if (!credential.apiKey) {
+      throw new Error(`API key not found for service: ${query.service}`);
+    }
+    return Redacted.make(credential.apiKey);
+  });
+};
+
+// src/Header.ts
+var Header_exports = {};
+__export(Header_exports, {
+  byokLayer: () => byokLayer
+});
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Effect4 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { BYOK_HEADER } from "@dxos/protocols";
+var byokLayer = (providerHost) => Layer.effect(HttpClient.HttpClient, Effect4.gen(function* () {
+  const client = yield* HttpClient.HttpClient;
+  const credentials = yield* CredentialsService;
+  return HttpClient.mapRequestEffect(client, (request) => Effect4.gen(function* () {
+    const matches = yield* Effect4.tryPromise(() => credentials.queryCredentials({
+      service: providerHost
+    })).pipe(Effect4.orElseSucceed(() => []));
+    const apiKey = matches.find((credential) => credential.apiKey)?.apiKey;
+    return apiKey ? HttpClientRequest.setHeader(request, BYOK_HEADER, apiKey) : request;
+  }));
+}));
+
+// src/LayerSpec.ts
+var LayerSpec_exports = {};
+__export(LayerSpec_exports, {
+  TypeId: () => TypeId,
+  make: () => make4
+});
+var TypeId = "~@dxos/functions/LayerSpec";
+var make4 = (opts, make11) => {
+  return {
+    [TypeId]: TypeId,
+    affinity: opts.affinity,
+    requires: opts.requires,
+    provides: opts.provides,
+    make: make11
+  };
+};
+
+// src/OperationRegistry.ts
+var OperationRegistry_exports = {};
+__export(OperationRegistry_exports, {
+  Service: () => Service,
+  layer: () => layer,
+  resolve: () => resolve2
+});
+import * as Context2 from "effect/Context";
+import * as Effect5 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import { Database as Database3, Filter as Filter3, Query } from "@dxos/echo";
+var Service = class extends Context2.Tag("@dxos/operation/OperationRegistry")() {
+};
+var resolve2 = Effect5.serviceFunctionEffect(Service, (service) => service.resolve);
+var layer = Layer2.effect(Service, Effect5.gen(function* () {
+  const database = yield* Database3.Service;
+  const handlerSet = yield* OperationHandlerProvider;
+  return {
+    resolve: (key2) => Database3.query(Query.select(Filter3.and(Filter3.type(PersistentOperation), Filter3.key(key2)))).first.pipe(Effect5.flatten, Effect5.map(deserialize), Effect5.catchTag("NoSuchElementException", () => getHandlerByKey(handlerSet, key2)), Effect5.option).pipe(Effect5.provideService(Database3.Service, database))
+  };
+}));
+
+// src/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: () => make5,
+  prettyProcessTree: () => prettyProcessTree
+});
+import * as Context4 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Schema5 from "effect/Schema";
+import { assertArgument as assertArgument2 } from "@dxos/invariant";
+import { DXN as DXN4 } from "@dxos/keys";
+import { log as log3 } from "@dxos/log";
+
+// src/Trace.ts
+var Trace_exports = {};
+__export(Trace_exports, {
+  CommonRuntimeName: () => CommonRuntimeName,
+  Event: () => Event,
+  EventType: () => EventType,
+  Message: () => Message,
+  MessageData: () => MessageData,
+  Meta: () => Meta,
+  OperationEnd: () => OperationEnd,
+  OperationInput: () => OperationInput,
+  OperationOutput: () => OperationOutput,
+  OperationStart: () => OperationStart,
+  RuntimeName: () => RuntimeName,
+  StatusUpdate: () => StatusUpdate,
+  TraceService: () => TraceService,
+  TraceSink: () => TraceSink,
+  emitStatus: () => emitStatus,
+  flatten: () => flatten2,
+  isEdgeRuntime: () => isEdgeRuntime,
+  isOfType: () => isOfType,
+  layerConsole: () => layerConsole,
+  layerNoop: () => layerNoop,
+  mergeSinks: () => mergeSinks,
+  noopSink: () => noopSink,
+  noopWriter: () => noopWriter,
+  testTraceService: () => testTraceService,
+  write: () => write,
+  writerLayerNoop: () => writerLayerNoop
+});
+import * as Context3 from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+import * as Schema4 from "effect/Schema";
+import { DXN as DXN3, Annotation as Annotation2, Obj as Obj2, Type as Type2 } from "@dxos/echo";
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/compute/src/Trace.ts";
+var TraceService = class extends Context3.Tag("@dxos/functions/TraceService")() {
+};
+function write(eventType, payload) {
+  return Effect6.gen(function* () {
+    log2("trace write", {
+      key: eventType.key,
+      isEphemeral: eventType.isEphemeral
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 20, S: this });
+    const writer = yield* TraceService;
+    writer.write(eventType, payload);
+  });
+}
+var EventType = (key2, opts) => {
+  return {
+    key: key2,
+    schema: opts.schema,
+    isEphemeral: opts.isEphemeral
+  };
+};
+var Event = Schema4.Struct({
+  timestamp: Schema4.Number,
+  type: Schema4.String,
+  data: Schema4.Unknown
+});
+var isOfType = (eventType, event) => {
+  return event.type === eventType.key;
+};
+var RuntimeName = Schema4.String.pipe(Schema4.brand("@dxos/compute/Trace/RuntimeName"));
+var CommonRuntimeName = {
+  /**
+  * Web app / CLI / Desktop app / Mobile app.
+  */
+  local: RuntimeName.make("local"),
+  edgeIntrinsic: RuntimeName.make("edge-intrinsic"),
+  edgeWorkerLoader: RuntimeName.make("edge-worker-loader"),
+  edgeWorkerForPlatforms: RuntimeName.make("edge-worker-for-platforms")
+};
+var Meta = Schema4.Struct({
+  pid: Schema4.optional(Schema4.String),
+  parentPid: Schema4.optional(Schema4.String),
+  processName: Schema4.optional(Schema4.String),
+  /**
+  * Space the message was produced in.
+  * Stored as a string to avoid circular dependency on `@dxos/keys`.
+  */
+  space: Schema4.optional(Schema4.String),
+  /**
+  * ID of the conversation feed object if present.
+  */
+  conversationId: Schema4.optional(Obj2.ID),
+  /**
+  * ID of the trigger object if invocation resulted from a trigger.
+  */
+  triggerId: Schema4.optional(Obj2.ID),
+  /**
+  * ID of the tool call that created the current process.
+  */
+  toolCallId: Schema4.optional(Schema4.String),
+  /**
+  * Extensible name informing which runtime executed the code that produced the event.
+  */
+  runtimeName: Schema4.optional(RuntimeName)
+});
+var isEdgeRuntime = (name) => name === CommonRuntimeName.edgeIntrinsic || name === CommonRuntimeName.edgeWorkerLoader || name === CommonRuntimeName.edgeWorkerForPlatforms;
+var MessageData = Schema4.Struct({
+  meta: Meta,
+  isEphemeral: Schema4.Boolean,
+  events: Schema4.Array(Event)
+});
+var Message = MessageData.pipe(Annotation2.IconAnnotation.set({
+  icon: "ph--note--regular",
+  hue: "rose"
+}), Annotation2.HiddenAnnotation.set(true), Type2.makeObject(DXN3.make("org.dxos.type.traceMessage", "0.1.0")));
+var flatten2 = (message) => {
+  return message.events.map((event) => ({
+    ...event,
+    meta: message.meta,
+    isEphemeral: message.isEphemeral
+  }));
+};
+var TraceSink = class extends Context3.Tag("@dxos/functions/TraceSink")() {
+};
+var noopWriter = {
+  write: () => {
+  }
+};
+var writerLayerNoop = Layer3.succeed(TraceService, noopWriter);
+var noopSink = {
+  write: () => {
+  }
+};
+var layerNoop = Layer3.succeed(TraceSink, noopSink);
+var layerConsole = Layer3.succeed(TraceSink, {
+  write: (message) => {
+    console.log(message);
+  }
+});
+var mergeSinks = (sinks) => {
+  if (sinks.length === 0) {
+    return noopSink;
+  }
+  return {
+    write: (message) => {
+      for (const sink of sinks) {
+        try {
+          sink.write(message);
+        } catch (err) {
+          console.error("[trace] sink.write threw", err);
+        }
+      }
+    }
+  };
+};
+var testTraceService = (opts = {}) => Layer3.effect(TraceService, Effect6.gen(function* () {
+  const sink = yield* TraceSink;
+  const clock = opts.clock ?? Date.now;
+  return {
+    write: (event, data) => {
+      sink.write(Obj2.make(Message, {
+        meta: opts.meta ?? {},
+        isEphemeral: event.isEphemeral,
+        events: [
+          {
+            type: event.key,
+            timestamp: clock(),
+            data
+          }
+        ]
+      }));
+    }
+  };
+}));
+var OperationStart = EventType("operation.start", {
+  schema: Schema4.Struct({
+    /** Operation key. */
+    key: Schema4.String,
+    /** Human-readable operation name. */
+    name: Schema4.optional(Schema4.String),
+    /** Phosphor icon identifier in `ph--<name>--<variant>` format. */
+    icon: Schema4.optional(Schema4.String)
+  }),
+  isEphemeral: false
+});
+var OperationEnd = EventType("operation.end", {
+  schema: Schema4.Struct({
+    /** Operation key. */
+    key: Schema4.String,
+    /** Human-readable operation name. */
+    name: Schema4.optional(Schema4.String),
+    /** Phosphor icon identifier in `ph--<name>--<variant>` format. */
+    icon: Schema4.optional(Schema4.String),
+    /** Outcome of the operation. */
+    outcome: Schema4.Literal("success", "failure"),
+    /** Error message if the operation failed. */
+    error: Schema4.optional(Schema4.String)
+  }),
+  isEphemeral: false
+});
+var OperationInput = EventType("operation.input", {
+  schema: Schema4.Struct({
+    /** Operation key. */
+    key: Schema4.String,
+    /** Human-readable operation name. */
+    name: Schema4.optional(Schema4.String),
+    /** Raw operation input. Shape determined by the operation definition. */
+    input: Schema4.Unknown
+  }),
+  isEphemeral: true
+});
+var OperationOutput = EventType("operation.output", {
+  schema: Schema4.Struct({
+    /** Operation key. */
+    key: Schema4.String,
+    /** Human-readable operation name. */
+    name: Schema4.optional(Schema4.String),
+    /** Raw operation output. Shape determined by the operation definition. */
+    output: Schema4.Unknown
+  }),
+  isEphemeral: true
+});
+var StatusUpdate = EventType("status.update", {
+  schema: Schema4.Struct({
+    /** Human-readable status message. */
+    message: Schema4.String
+  }),
+  isEphemeral: true
+});
+var emitStatus = (message) => write(StatusUpdate, {
+  message
+});
+
+// src/Process.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/compute/compute/src/Process.ts";
+var ID = Schema5.String.pipe(Schema5.brand("ProcessId"));
+var ProcessTypeId = "~@dxos/functions/Process";
+var isProcess = (executable) => typeof executable === "object" && executable !== null && ProcessTypeId in executable;
+var make5 = (opts, create) => {
+  assertArgument2(/^[a-z0-9]([a-z0-9.\-/]*[a-z0-9])?$/i.test(opts.key), "key", "Invalid key");
+  return {
+    [ProcessTypeId]: {},
+    ...opts,
+    create: (ctx) => create(ctx).pipe(Effect7.map((partial) => ({
+      onSpawn: () => Effect7.void,
+      onInput: () => Effect7.void,
+      onAlarm: () => Effect7.void,
+      onChildEvent: () => Effect7.void,
+      ...partial
+    })))
+  };
+};
+var OperationStartedKey = key(Schema5.parseJson(Schema5.Boolean), "operation/started").pipe(withDefault(() => false));
+var fromOperation = (op, handler) => make5({
+  key: DXN4.getName(op.meta.key),
+  input: op.input,
+  output: op.output,
+  services: op.services
+}, (ctx) => Effect7.gen(function* () {
+  const semaphore = yield* Effect7.makeSemaphore(1);
+  const idempotent = isIdempotent(op);
+  return {
+    onInput: (input) => Effect7.gen(function* () {
+      if (!idempotent) {
+        const started = yield* OperationStartedKey.get;
+        if (started) {
+          return yield* Effect7.die(new Error(`non-idempotent operation "${op.meta.key}" was interrupted; cannot retry safely`));
+        }
+        yield* OperationStartedKey.set(true);
+      }
+      log3("operation process invoking", {
+        key: op.meta.key,
+        name: op.meta.name
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 66, S: this });
+      yield* write(OperationStart, {
+        key: op.meta.key,
+        name: op.meta.name,
+        icon: op.meta.icon
+      });
+      yield* write(OperationInput, {
+        key: op.meta.key,
+        name: op.meta.name,
+        input
+      });
+      const opHandler = yield* getHandler(handler, op).pipe(Effect7.orDie);
+      const output = yield* opHandler.handler(input).pipe(Effect7.orDie, Effect7.withSpan(op.meta.key));
+      ctx.submitOutput(output);
+      ctx.succeed();
+      yield* write(OperationOutput, {
+        key: op.meta.key,
+        name: op.meta.name,
+        output
+      });
+      yield* write(OperationEnd, {
+        key: op.meta.key,
+        name: op.meta.name,
+        icon: op.meta.icon,
+        outcome: "success"
+      });
+    }).pipe(Effect7.catchAllDefect((defect) => Effect7.gen(function* () {
+      const errorMessage = defect instanceof Error ? defect.message : String(defect);
+      yield* write(OperationEnd, {
+        key: op.meta.key,
+        name: op.meta.name,
+        icon: op.meta.icon,
+        outcome: "failure",
+        error: errorMessage
+      });
+      return yield* Effect7.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 Context4.Tag("@dxos/functions/ProcessMonitorService")() {
+};
+var SpawnedEvent = EventType("process.spawned", {
+  schema: Schema5.Void,
+  isEphemeral: false
+});
+var ExitedEvent = EventType("process.exited", {
+  schema: Schema5.Struct({
+    outcome: Schema5.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/Routine.ts
+var Routine_exports = {};
+__export(Routine_exports, {
+  Routine: () => Routine,
+  make: () => make6
+});
+import * as Schema6 from "effect/Schema";
+import { DXN as DXN5, Annotation as Annotation3, JsonSchema, Obj as Obj3, Ref as Ref2, Type as Type3, Format } from "@dxos/echo";
+import { Text as Text2 } from "@dxos/schema";
+var Routine = Schema6.Struct({
+  name: Schema6.optional(Schema6.String),
+  description: Schema6.optional(Schema6.String),
+  input: JsonSchema.JsonSchema.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
+    description: "Input schema"
+  }),
+  output: JsonSchema.JsonSchema.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
+    description: "Output schema"
+  }),
+  instructions: Ref2.Ref(Text2.Text).pipe(Format.FormatAnnotation.set(Format.TypeFormat.Markdown), Schema6.annotations({
+    title: "Instructions",
+    description: "Agent instructions"
+  })),
+  blueprints: Schema6.Array(Ref2.Ref(Blueprint)),
+  context: Schema6.Array(Schema6.Any).pipe(Annotation3.FormInputAnnotation.set(false))
+}).pipe(Annotation3.LabelAnnotation.set([
+  "name"
+]), Annotation3.IconAnnotation.set({
+  icon: "ph--scroll--regular",
+  hue: "sky"
+}), Type3.makeObject(DXN5.make("org.dxos.type.routine", "0.1.0")));
+var make6 = ({ name, description, input, output, instructions, blueprints = [], context = [] }) => Obj3.make(Routine, {
+  name,
+  description,
+  input: JsonSchema.toJsonSchema(input ?? Schema6.Void),
+  output: JsonSchema.toJsonSchema(output ?? Schema6.Void),
+  instructions: Ref2.make(Text2.make({
+    content: instructions ?? ""
+  })),
+  blueprints,
+  context
+});
+
+// src/Script.ts
+var Script_exports = {};
+__export(Script_exports, {
+  Script: () => Script,
+  make: () => make7
+});
+import * as Schema7 from "effect/Schema";
+import { DXN as DXN6, Annotation as Annotation4, Obj as Obj4, Ref as Ref3, Type as Type4 } from "@dxos/echo";
+import { FormInputAnnotation } from "@dxos/echo/Annotation";
+import { Text as Text3 } from "@dxos/schema";
+var Script = Schema7.Struct({
+  name: Schema7.String.pipe(Schema7.optional),
+  description: Schema7.String.pipe(Schema7.optional),
+  // TODO(burdon): Change to hash of deployed content.
+  // Whether source has changed since last deploy.
+  changed: Schema7.Boolean.pipe(FormInputAnnotation.set(false), Schema7.optional),
+  source: Ref3.Ref(Text3.Text).pipe(FormInputAnnotation.set(false))
+}).pipe(Annotation4.LabelAnnotation.set([
+  "name"
+]), Annotation4.IconAnnotation.set({
+  icon: "ph--code--regular",
+  hue: "sky"
+}), Type4.makeObject(DXN6.make("org.dxos.type.script", "0.1.0")));
+var make7 = ({ source = "", ...props } = {}) => Obj4.make(Script, {
+  ...props,
+  source: Ref3.make(Text3.make({
+    content: source
+  }))
+});
+
+// src/ServiceResolver.ts
+var ServiceResolver_exports = {};
+__export(ServiceResolver_exports, {
+  ServiceResolver: () => ServiceResolver,
+  compose: () => compose,
+  empty: () => empty2,
+  fromContext: () => fromContext,
+  fromRequirements: () => fromRequirements,
+  layerRequirements: () => layerRequirements,
+  make: () => make9,
+  provide: () => provide,
+  resolve: () => resolve3,
+  resolveAll: () => resolveAll,
+  succeed: () => succeed2
+});
+import * as Context5 from "effect/Context";
+import * as Effect8 from "effect/Effect";
+import * as Either from "effect/Either";
+import * as Layer4 from "effect/Layer";
+import * as Option from "effect/Option";
+var ServiceResolverTypeId = "~@dxos/functions/ServiceResolver";
+var ServiceResolver = Context5.GenericTag("@dxos/functions/ServiceResolver");
+var resolve3 = Effect8.serviceFunctionEffect(ServiceResolver, (_) => _.resolve);
+var resolveAll = (tags, context) => Effect8.gen(function* () {
+  const services = yield* Effect8.forEach(tags, (tag) => resolve3(tag, context).pipe(Effect8.map((service) => Context5.make(tag, service))));
+  return Context5.mergeAll(...services);
+});
+var succeed2 = (tag, getService) => {
+  return make9((tag1, context) => {
+    if (tag1.key !== tag.key) {
+      return Effect8.fail(new ServiceNotAvailableError(`Service not available: ${String(tag.key ?? tag)}`));
+    }
+    const service = getService(context);
+    return service;
+  });
+};
+var make9 = (resolveFn) => ({
+  [ServiceResolverTypeId]: ServiceResolverTypeId,
+  resolve: resolveFn
+});
+var fromContext = (ctx) => make9((tag, context) => Effect8.gen(function* () {
+  const service = Context5.getOption(ctx, tag);
+  if (Option.isNone(service)) {
+    return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+  }
+  return service.value;
+}));
+var fromRequirements = (...tags) => Effect8.contextWith((parentCtx) => {
+  const available = new Set(tags.map((tag) => tag.key));
+  return make9((tag, context) => Effect8.gen(function* () {
+    let result = Context5.empty();
+    if (!available.has(tag.key)) {
+      return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+    }
+    const service = Context5.getOption(parentCtx, tag);
+    if (Option.isNone(service)) {
+      return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+    }
+    return service.value;
+  }));
+});
+var layerRequirements = (...tags) => Layer4.effect(ServiceResolver, fromRequirements(...tags));
+var provide = (context, ...tags) => Layer4.scopedContext(resolveAll(tags, context));
+var compose = (...resolvers) => make9((tag, context) => Effect8.gen(function* () {
+  for (const resolver of resolvers) {
+    const single = yield* resolver.resolve(tag, context).pipe(Effect8.either);
+    if (Either.isRight(single)) {
+      return single.right;
+    }
+  }
+  return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+}));
+var empty2 = make9((tag, context) => {
+  return Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+});
+
+// src/Trigger.ts
+var Trigger_exports = {};
+__export(Trigger_exports, {
+  EmailSpec: () => EmailSpec,
+  FeedSpec: () => FeedSpec,
+  Kinds: () => Kinds,
+  Spec: () => Spec,
+  SubscriptionSpec: () => SubscriptionSpec,
+  TimerSpec: () => TimerSpec,
+  Trigger: () => Trigger,
+  WebhookSpec: () => WebhookSpec,
+  make: () => make10,
+  specEmail: () => specEmail,
+  specFeed: () => specFeed,
+  specSubscription: () => specSubscription,
+  specTimer: () => specTimer,
+  specWebhook: () => specWebhook
+});
+import * as Schema8 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { DXN as DXN7, Annotation as Annotation5, Feed, Obj as Obj5, QueryAST, Ref as Ref4, Type as Type5 } from "@dxos/echo";
+import { HiddenAnnotation } from "@dxos/echo/Annotation";
+import { OptionsAnnotationId } from "@dxos/echo/Format";
+var Kinds = [
+  "email",
+  "feed",
+  "subscription",
+  "timer",
+  "webhook"
+];
+var kindLiteralAnnotations = {
+  title: "Kind"
+};
+var EmailSpec = Schema8.Struct({
+  kind: Schema8.Literal("email").annotations(kindLiteralAnnotations)
+});
+var specEmail = () => ({
+  kind: "email"
+});
+var FeedSpec = Schema8.Struct({
+  kind: Schema8.Literal("feed").annotations(kindLiteralAnnotations),
+  feed: Schema8.optional(Ref4.Ref(Feed.Feed).annotations({
+    title: "Feed"
+  }))
+});
+var specFeed = (feed) => ({
+  kind: "feed",
+  feed: Ref4.make(feed)
+});
+var SubscriptionSpec = Schema8.Struct({
+  kind: Schema8.Literal("subscription").annotations(kindLiteralAnnotations),
+  query: Schema8.Struct({
+    raw: Schema8.optional(Schema8.String.annotations({
+      title: "Query"
+    })),
+    ast: QueryAST.Query
+  }),
+  options: Schema8.optional(Schema8.Struct({
+    // Watch changes to object (not just creation).
+    deep: Schema8.optional(Schema8.Boolean.annotations({
+      title: "Nested"
+    })),
+    // Debounce changes (delay in ms).
+    delay: Schema8.optional(Schema8.Number.annotations({
+      title: "Delay"
+    }))
+  }).annotations({
+    title: "Options"
+  }))
+});
+var specSubscription = (query, options) => ({
+  kind: "subscription",
+  query: {
+    ast: query.ast
+  },
+  options: options ? {
+    deep: options.deep,
+    delay: options.delay
+  } : void 0
+});
+var TimerSpec = Schema8.Struct({
+  kind: Schema8.Literal("timer").annotations(kindLiteralAnnotations),
+  cron: Schema8.String.annotations({
+    title: "Cron",
+    [SchemaAST.ExamplesAnnotationId]: [
+      "0 0 * * *"
+    ]
+  })
+});
+var specTimer = (cron) => ({
+  kind: "timer",
+  cron
+});
+var WebhookSpec = Schema8.Struct({
+  kind: Schema8.Literal("webhook").annotations(kindLiteralAnnotations),
+  method: Schema8.optional(Schema8.String.annotations({
+    title: "Method",
+    [OptionsAnnotationId]: [
+      "GET",
+      "POST"
+    ]
+  })),
+  port: Schema8.optional(Schema8.Number.annotations({
+    title: "Port"
+  }))
+});
+var specWebhook = (opts) => ({
+  kind: "webhook",
+  method: opts?.method,
+  port: opts?.port
+});
+var Spec = Schema8.Union(EmailSpec, FeedSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
+  title: "Trigger"
+});
+var TriggerSchema = Schema8.Struct({
+  /**
+  * Function or workflow to invoke.
+  */
+  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
+  function: Schema8.optional(Ref4.Ref(Obj5.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: Schema8.optional(Schema8.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: Schema8.optional(Schema8.Boolean.annotations({
+    title: "Enabled"
+  })),
+  spec: Schema8.optional(Spec),
+  concurrency: Schema8.optional(Schema8.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: { '/': 'echo://AAA/ZZZ' }
+  * }
+  */
+  input: Schema8.optional(Schema8.Record({
+    key: Schema8.String,
+    value: Schema8.Any
+  }))
+}).pipe(Annotation5.IconAnnotation.set({
+  icon: "ph--lightning--regular",
+  hue: "yellow"
+}), HiddenAnnotation.set(true), Type5.makeObject(DXN7.make("org.dxos.type.trigger", "0.1.0")));
+var Trigger = TriggerSchema;
+var make10 = (props) => Obj5.make(Trigger, props);
+
+// src/TriggerEvent.ts
+var TriggerEvent_exports = {};
+__export(TriggerEvent_exports, {
+  EmailEvent: () => EmailEvent,
+  FeedEvent: () => FeedEvent,
+  SubscriptionEvent: () => SubscriptionEvent,
+  TimerEvent: () => TimerEvent,
+  TriggerEvent: () => TriggerEvent,
+  WebhookEvent: () => WebhookEvent
+});
+import * as Schema9 from "effect/Schema";
+import { Feed as Feed2, Obj as Obj6, Ref as Ref5 } from "@dxos/echo";
+var EmailEvent = Schema9.Struct({
+  from: Schema9.String,
+  to: Schema9.String,
+  subject: Schema9.String,
+  created: Schema9.String,
+  body: Schema9.String
+});
+var FeedEvent = Schema9.Struct({
+  feed: Ref5.Ref(Feed2.Feed),
+  item: Schema9.Any,
+  cursor: Schema9.String
+});
+var SubscriptionEvent = Schema9.Struct({
+  /**
+  * Type of the mutation.
+  */
+  // TODO(dmaretskyi): Specify enum.
+  type: Schema9.String,
+  /**
+  * Reference to the object that was changed or created.
+  */
+  subject: Ref5.Ref(Obj6.Unknown),
+  /**
+  * @deprecated
+  */
+  changedObjectId: Schema9.optional(Schema9.String)
+});
+var TimerEvent = Schema9.Struct({
+  tick: Schema9.Number
+});
+var WebhookEvent = Schema9.Struct({
+  url: Schema9.String,
+  method: Schema9.Literal("GET", "POST"),
+  headers: Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.String
+  }),
+  bodyText: Schema9.String
+});
+var TriggerEvent = Schema9.Union(EmailEvent, FeedEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
+export {
+  Blueprint_exports as Blueprint,
+  Credential_exports as Credential,
+  FunctionError,
+  FunctionNotFoundError,
+  FunctionsAiMemoizationMissError,
+  FunctionsAiUpstreamError,
+  Header_exports as Header,
+  InvalidOperationInputError,
+  InvalidOperationOutputError,
+  InvokerNotInitializedError,
+  LayerSpec_exports as LayerSpec,
+  McpServer_exports as McpServer,
+  NoHandlerError,
+  Operation_exports as Operation,
+  OperationHandlerSet_exports as OperationHandlerSet,
+  OperationRegistry_exports as OperationRegistry,
+  Process_exports as Process,
+  Routine_exports as Routine,
+  Script_exports as Script,
+  ServiceNotAvailableError,
+  ServiceResolver_exports as ServiceResolver,
+  StorageService_exports as StorageService,
+  Template_exports as Template,
+  Trace_exports as Trace,
+  Trigger_exports as Trigger,
+  TriggerEvent_exports as TriggerEvent,
+  TriggerStateNotFoundError
+};
+//# sourceMappingURL=index.mjs.map