@dxos/functions 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/README.md

@@ -27,11 +27,9 @@ import { FunctionContext } from '@dxos/functions';
 
 export default (event: any, context: FunctionContext) => {
   const identity = context.client.halo.identity.get();
-  return context
-    .status(200)
-    .succeed({ 
-      message: `Hello ${identity?.profile?.displayName}` 
-    });
+  return context.status(200).succeed({
+    message: `Hello ${identity?.profile?.displayName}`,
+  });
 };
 ```
 
@@ -69,7 +67,7 @@ nodemon -w ./src -e ts --exec $(git rev-parse --show-toplevel)/packages/devtools
 > NOTE: The port (7001) must match the one in config.
 
 ```bash
-curl http://localhost:7001/dev/hello -X POST -H 'Content-Type: application/json' -w '\n' --data '{ "message": "Hello World!" }' 
+curl http://localhost:7001/dev/hello -X POST -H 'Content-Type: application/json' -w '\n' --data '{ "message": "Hello World!" }'
 ```
 
 ## DXOS Resources

package/dist/lib/neutral/Trace.mjs

@@ -0,0 +1,42 @@
+import {
+  Event,
+  EventType,
+  Message,
+  MessageData,
+  Meta,
+  OperationEnd,
+  OperationStart,
+  StatusUpdate,
+  TraceService,
+  TraceSink,
+  emitStatus,
+  isOfType,
+  layerConsole,
+  layerNoop,
+  noopWriter,
+  testTraceService,
+  write,
+  writerLayerNoop
+} from "./chunk-27Y24OTY.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  Event,
+  EventType,
+  Message,
+  MessageData,
+  Meta,
+  OperationEnd,
+  OperationStart,
+  StatusUpdate,
+  TraceService,
+  TraceSink,
+  emitStatus,
+  isOfType,
+  layerConsole,
+  layerNoop,
+  noopWriter,
+  testTraceService,
+  write,
+  writerLayerNoop
+};
+//# sourceMappingURL=Trace.mjs.map

package/dist/lib/neutral/Trace.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/chunk-27Y24OTY.mjs

@@ -0,0 +1,167 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Trace.ts
+var Trace_exports = {};
+__export(Trace_exports, {
+  Event: () => Event,
+  EventType: () => EventType,
+  Message: () => Message,
+  MessageData: () => MessageData,
+  Meta: () => Meta,
+  OperationEnd: () => OperationEnd,
+  OperationStart: () => OperationStart,
+  StatusUpdate: () => StatusUpdate,
+  TraceService: () => TraceService,
+  TraceSink: () => TraceSink,
+  emitStatus: () => emitStatus,
+  isOfType: () => isOfType,
+  layerConsole: () => layerConsole,
+  layerNoop: () => layerNoop,
+  noopWriter: () => noopWriter,
+  testTraceService: () => testTraceService,
+  write: () => write,
+  writerLayerNoop: () => writerLayerNoop
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { Annotation, Obj, Type } from "@dxos/echo";
+var TraceService = class extends Context.Tag("@dxos/functions/TraceService")() {
+};
+var write = Effect.serviceFunction(TraceService, (_) => _.write);
+var EventType = (key, opts) => {
+  return {
+    key,
+    schema: opts.schema,
+    isEphemeral: opts.isEphemeral
+  };
+};
+var Event = Schema.Struct({
+  timestamp: Schema.Number,
+  type: Schema.String,
+  data: Schema.Unknown
+});
+var isOfType = (eventType, event) => {
+  return event.type === eventType.key;
+};
+var Meta = Schema.Struct({
+  pid: Schema.optional(Schema.String),
+  parentPid: Schema.optional(Schema.String),
+  processName: Schema.optional(Schema.String),
+  /**
+  * ID of the conversation feed object if present.
+  */
+  conversationId: Schema.optional(Obj.ID),
+  /**
+  * ID of the trigger object if invocation resulted from a trigger.
+  */
+  triggerId: Schema.optional(Obj.ID),
+  /**
+  * ID of the tool call that created the current process.
+  */
+  toolCallId: Schema.optional(Schema.String)
+});
+var MessageData = Schema.Struct({
+  meta: Meta,
+  isEphemeral: Schema.Boolean,
+  events: Schema.Array(Event)
+});
+var Message = MessageData.pipe(Type.object({
+  typename: "org.dxos.type.traceMessage",
+  version: "0.1.0"
+}), Annotation.IconAnnotation.set({
+  icon: "ph--note--regular",
+  hue: "rose"
+}));
+var TraceSink = class extends Context.Tag("@dxos/functions/TraceSink")() {
+};
+var noopWriter = {
+  write: () => {
+  }
+};
+var writerLayerNoop = Layer.succeed(TraceService, noopWriter);
+var layerNoop = Layer.succeed(TraceSink, {
+  write: () => {
+  }
+});
+var layerConsole = Layer.succeed(TraceSink, {
+  write: (message) => {
+    console.log(message);
+  }
+});
+var testTraceService = (opts = {}) => Layer.effect(TraceService, Effect.gen(function* () {
+  const sink = yield* TraceSink;
+  return {
+    write: (event, data) => {
+      sink.write(Obj.make(Message, {
+        meta: opts.meta ?? {},
+        isEphemeral: event.isEphemeral,
+        events: [
+          {
+            type: event.key,
+            timestamp: Date.now(),
+            data
+          }
+        ]
+      }));
+    }
+  };
+}));
+var OperationStart = EventType("operation.start", {
+  schema: Schema.Struct({
+    /** Operation key. */
+    key: Schema.String,
+    /** Human-readable operation name. */
+    name: Schema.optional(Schema.String)
+  }),
+  isEphemeral: false
+});
+var OperationEnd = EventType("operation.end", {
+  schema: Schema.Struct({
+    /** Operation key. */
+    key: Schema.String,
+    /** Human-readable operation name. */
+    name: Schema.optional(Schema.String),
+    /** Outcome of the operation. */
+    outcome: Schema.Literal("success", "failure"),
+    /** Error message if the operation failed. */
+    error: Schema.optional(Schema.String)
+  }),
+  isEphemeral: false
+});
+var StatusUpdate = EventType("status.update", {
+  schema: Schema.Struct({
+    /** Human-readable status message. */
+    message: Schema.String
+  }),
+  isEphemeral: true
+});
+var emitStatus = (message) => write(StatusUpdate, {
+  message
+});
+
+export {
+  TraceService,
+  write,
+  EventType,
+  Event,
+  isOfType,
+  Meta,
+  MessageData,
+  Message,
+  TraceSink,
+  noopWriter,
+  writerLayerNoop,
+  layerNoop,
+  layerConsole,
+  testTraceService,
+  OperationStart,
+  OperationEnd,
+  StatusUpdate,
+  emitStatus,
+  Trace_exports
+};
+//# sourceMappingURL=chunk-27Y24OTY.mjs.map

package/dist/lib/neutral/chunk-27Y24OTY.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Trace.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Schema from 'effect/Schema';\n\nimport { Annotation, Obj, Type } from '@dxos/echo';\n\n/**\n * Writes ephemeral or persistent events to the trace.\n * Exposed to processes and operations to record events to the trace.\n */\nexport interface TraceWriter {\n  write<T>(eventType: EventType<T>, payload: NoInfer<T>): void;\n}\n\n/**\n * Service that writes events to the trace.\n * Exposed to processes and operations to record events to the trace.\n */\nexport class TraceService extends Context.Tag('@dxos/functions/TraceService')<TraceService, TraceWriter>() {}\n\n/**\n * Writes an event to the trace.\n */\nexport const write: <T>(eventType: EventType<T>, payload: NoInfer<T>) => Effect.Effect<void, never, TraceService> =\n  Effect.serviceFunction(TraceService, (_) => _.write);\n\n/**\n * Defines an event type for the trace.\n */\nexport interface EventType<T> {\n  readonly key: string;\n  readonly schema: Schema.Schema<T, any>;\n  readonly isEphemeral: boolean;\n}\n\nexport const EventType = <T>(\n  key: string,\n  opts: { schema: Schema.Schema<T, any>; isEphemeral: boolean },\n): EventType<T> => {\n  return {\n    key,\n    schema: opts.schema,\n    isEphemeral: opts.isEphemeral,\n  };\n};\n\n/**\n * Extracts the payload type from an event type.\n */\nexport type PayloadType<E extends EventType<any>> = E extends EventType<infer T> ? T : never;\n\nexport const Event = Schema.Struct({\n  timestamp: Schema.Number,\n  type: Schema.String,\n  data: Schema.Unknown, // Type-specific payload;\n});\nexport interface Event extends Schema.Schema.Type<typeof Event> {}\n\n/**\n * Checks if an event is of a given type.\n */\nexport const isOfType = <T, E extends Event>(eventType: EventType<T>, event: E): event is E & { data: T } => {\n  return event.type === eventType.key;\n};\n\n/**\n * Metadata on the context of a trace message.\n */\n// TODO(dmaretskyi): Expand on this: conversation id, tool call id, etc.\nexport const Meta = Schema.Struct({\n  pid: Schema.optional(Schema.String), // NOTE: Not Process.ID to avoid circular dependency.\n  parentPid: Schema.optional(Schema.String),\n  processName: Schema.optional(Schema.String),\n\n  /**\n   * ID of the conversation feed object if present.\n   */\n  conversationId: Schema.optional(Obj.ID),\n\n  /**\n   * ID of the trigger object if invocation resulted from a trigger.\n   */\n  triggerId: Schema.optional(Obj.ID),\n\n  /**\n   * ID of the tool call that created the current process.\n   */\n  toolCallId: Schema.optional(Schema.String),\n});\nexport interface Meta extends Schema.Schema.Type<typeof Meta> {}\n\n/**\n * Envelope for a set of events.\n */\nexport const MessageData = Schema.Struct({\n  meta: Meta,\n\n  isEphemeral: Schema.Boolean,\n  events: Schema.Array(Event),\n});\nexport interface MessageData extends Schema.Schema.Type<typeof MessageData> {}\n\nexport const Message = MessageData.pipe(\n  Type.object({\n    typename: 'org.dxos.type.traceMessage',\n    version: '0.1.0',\n  }),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--note--regular',\n    hue: 'rose',\n  }),\n);\nexport interface Message extends Schema.Schema.Type<typeof Message> {}\n\n/**\n * Sink for complete trace messages.\n */\nexport interface Sink {\n  write(message: Message): void;\n}\n\n/**\n * Sink for complete trace messages.\n * The Process Manager forwards trace messages to it.\n */\n// TODO(dmaretskyi): Consider moving sink to the Process Manager.\nexport class TraceSink extends Context.Tag('@dxos/functions/TraceSink')<TraceSink, Sink>() {}\n\nexport const noopWriter: TraceWriter = {\n  write: () => {},\n};\n\nexport const writerLayerNoop: Layer.Layer<TraceService> = Layer.succeed(TraceService, noopWriter);\n\nexport const layerNoop: Layer.Layer<TraceSink> = Layer.succeed(TraceSink, {\n  write: () => {},\n});\n\nexport const layerConsole: Layer.Layer<TraceSink> = Layer.succeed(TraceSink, {\n  write: (message) => {\n    console.log(message);\n  },\n});\n\nexport const testTraceService = (opts: { meta?: Meta } = {}): Layer.Layer<TraceService, never, TraceSink> =>\n  Layer.effect(\n    TraceService,\n    Effect.gen(function* () {\n      const sink = yield* TraceSink;\n      return {\n        write: (event, data) => {\n          sink.write(\n            Obj.make(Message, {\n              meta: opts.meta ?? {},\n              isEphemeral: event.isEphemeral,\n              events: [{ type: event.key, timestamp: Date.now(), data }],\n            }),\n          );\n        },\n      };\n    }),\n  );\n\n//\n// Operation Trace Events\n//\n\n/**\n * Outcome of an operation invocation.\n */\nexport type OperationOutcome = 'success' | 'failure';\n\n/**\n * Operation invocation started.\n */\nexport const OperationStart = EventType('operation.start', {\n  schema: Schema.Struct({\n    /** Operation key. */\n    key: Schema.String,\n    /** Human-readable operation name. */\n    name: Schema.optional(Schema.String),\n  }),\n  isEphemeral: false,\n});\n\n/**\n * Operation invocation ended.\n */\nexport const OperationEnd = EventType('operation.end', {\n  schema: Schema.Struct({\n    /** Operation key. */\n    key: Schema.String,\n    /** Human-readable operation name. */\n    name: Schema.optional(Schema.String),\n    /** Outcome of the operation. */\n    outcome: Schema.Literal('success', 'failure'),\n    /** Error message if the operation failed. */\n    error: Schema.optional(Schema.String),\n  }),\n  isEphemeral: false,\n});\n\n/**\n * Human-readable status update emitted by an agent or operation.\n */\nexport const StatusUpdate = EventType('status.update', {\n  schema: Schema.Struct({\n    /** Human-readable status message. */\n    message: Schema.String,\n  }),\n  isEphemeral: true,\n});\n\n/**\n * Emit the current human-readable execution status to the trace.\n */\nexport const emitStatus: (message: string) => Effect.Effect<void, never, TraceService> = (message) =>\n  write(StatusUpdate, { message });\n"],
+  "mappings": "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",
+  "names": ["Context", "Effect", "Layer", "Schema", "Annotation", "Obj", "Type", "TraceService", "Tag", "write", "serviceFunction", "_", "EventType", "key", "opts", "schema", "isEphemeral", "Event", "Struct", "timestamp", "Number", "type", "String", "data", "Unknown", "isOfType", "eventType", "event", "Meta", "pid", "optional", "parentPid", "processName", "conversationId", "Obj", "ID", "triggerId", "toolCallId", "MessageData", "meta", "Boolean", "events", "Array", "Message", "pipe", "Type", "object", "typename", "version", "Annotation", "IconAnnotation", "set", "icon", "hue", "TraceSink", "noopWriter", "writerLayerNoop", "succeed", "layerNoop", "layerConsole", "message", "console", "log", "testTraceService", "effect", "gen", "sink", "make", "Date", "now", "OperationStart", "name", "OperationEnd", "outcome", "Literal", "error", "StatusUpdate", "emitStatus"]
+}

package/dist/lib/neutral/chunk-IVDUS56O.mjs

@@ -0,0 +1,49 @@
+// src/example/definitions.ts
+import * as Schema from "effect/Schema";
+import { Operation } from "@dxos/operation";
+var Fibonacci = Operation.make({
+  meta: {
+    key: "example.org/function/fib",
+    name: "Fibonacci",
+    description: "Function that calculates a Fibonacci number"
+  },
+  input: Schema.Struct({
+    iterations: Schema.optional(Schema.Number).annotations({
+      description: "Number of iterations",
+      default: 1e5
+    })
+  }),
+  output: Schema.Struct({
+    result: Schema.String
+  })
+});
+var Reply = Operation.make({
+  meta: {
+    key: "example.org/function/reply",
+    name: "Reply",
+    description: "Function that echoes the input"
+  },
+  input: Schema.Any,
+  output: Schema.Any
+});
+var Sleep = Operation.make({
+  meta: {
+    key: "example.org/function/sleep",
+    name: "Sleep",
+    description: "Function that sleeps for a given amount of time"
+  },
+  input: Schema.Struct({
+    duration: Schema.optional(Schema.Number).annotations({
+      description: "Milliseconds to sleep",
+      default: 1e5
+    })
+  }),
+  output: Schema.Void
+});
+
+export {
+  Fibonacci,
+  Reply,
+  Sleep
+};
+//# sourceMappingURL=chunk-IVDUS56O.mjs.map

package/dist/lib/neutral/chunk-IVDUS56O.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/example/definitions.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Operation } from '@dxos/operation';\n\nexport const Fibonacci = Operation.make({\n  meta: {\n    key: 'example.org/function/fib',\n    name: 'Fibonacci',\n    description: 'Function that calculates a Fibonacci number',\n  },\n  input: Schema.Struct({\n    iterations: Schema.optional(Schema.Number).annotations({\n      description: 'Number of iterations',\n      default: 100_000,\n    }),\n  }),\n  output: Schema.Struct({\n    result: Schema.String,\n  }),\n});\n\nexport const Reply = Operation.make({\n  meta: {\n    key: 'example.org/function/reply',\n    name: 'Reply',\n    description: 'Function that echoes the input',\n  },\n  input: Schema.Any,\n  output: Schema.Any,\n});\n\nexport const Sleep = Operation.make({\n  meta: {\n    key: 'example.org/function/sleep',\n    name: 'Sleep',\n    description: 'Function that sleeps for a given amount of time',\n  },\n  input: Schema.Struct({\n    duration: Schema.optional(Schema.Number).annotations({\n      description: 'Milliseconds to sleep',\n      default: 100_000,\n    }),\n  }),\n  output: Schema.Void,\n});\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAEnB,IAAMC,YAAYC,UAAUC,KAAK;EACtCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBC,YAAmBC,gBAAgBC,aAAM,EAAEC,YAAY;MACrDN,aAAa;MACbO,SAAS;IACX,CAAA;EACF,CAAA;EACAC,QAAeN,cAAO;IACpBO,QAAeC;EACjB,CAAA;AACF,CAAA;AAEO,IAAMC,QAAQhB,UAAUC,KAAK;EAClCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcW;EACdJ,QAAeI;AACjB,CAAA;AAEO,IAAMC,QAAQlB,UAAUC,KAAK;EAClCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBY,UAAiBV,gBAAgBC,aAAM,EAAEC,YAAY;MACnDN,aAAa;MACbO,SAAS;IACX,CAAA;EACF,CAAA;EACAC,QAAeO;AACjB,CAAA;",
+  "names": ["Schema", "Operation", "Fibonacci", "Operation", "make", "meta", "key", "name", "description", "input", "Struct", "iterations", "optional", "Number", "annotations", "default", "output", "result", "String", "Reply", "Any", "Sleep", "duration", "Void"]
+}

package/dist/lib/neutral/chunk-J5LGTIGS.mjs

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/lib/neutral/chunk-J5LGTIGS.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/fib-N45KAC7C.mjs

@@ -0,0 +1,23 @@
+import {
+  Fibonacci
+} from "./chunk-IVDUS56O.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/example/fib.ts
+import * as Effect from "effect/Effect";
+import { Operation } from "@dxos/operation";
+var fib_default = Fibonacci.pipe(Operation.withHandler(Effect.fn(function* ({ iterations = 1e5 }) {
+  let a = 0n;
+  let b = 1n;
+  for (let i = 0; i < iterations; i++) {
+    a += b;
+    b = a - b;
+  }
+  return {
+    result: a.toString()
+  };
+})));
+export {
+  fib_default as default
+};
+//# sourceMappingURL=fib-N45KAC7C.mjs.map

package/dist/lib/neutral/fib-N45KAC7C.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/example/fib.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Operation } from '@dxos/operation';\n\nimport { Fibonacci } from './definitions';\n\nexport default Fibonacci.pipe(\n  Operation.withHandler(\n    Effect.fn(function* ({ iterations = 100_000 }) {\n      let a = 0n;\n      let b = 1n;\n      for (let i = 0; i < iterations; i++) {\n        a += b;\n        b = a - b;\n      }\n      return { result: a.toString() };\n    }),\n  ),\n);\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAI1B,IAAA,cAAeC,UAAUC,KACvBC,UAAUC,YACDC,UAAG,WAAW,EAAEC,aAAa,IAAO,GAAE;AAC3C,MAAIC,IAAI;AACR,MAAIC,IAAI;AACR,WAASC,IAAI,GAAGA,IAAIH,YAAYG,KAAK;AACnCF,SAAKC;AACLA,QAAID,IAAIC;EACV;AACA,SAAO;IAAEE,QAAQH,EAAEI,SAAQ;EAAG;AAChC,CAAA,CAAA,CAAA;",
+  "names": ["Effect", "Operation", "Fibonacci", "pipe", "Operation", "withHandler", "fn", "iterations", "a", "b", "i", "result", "toString"]
+}