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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.bc674ce",
+  "version": "0.8.4-main.bcb3aa67d6",
   "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -16,8 +16,12 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
+    },
+    "./Trace": {
+      "source": "./src/Trace.ts",
+      "types": "./dist/types/src/Trace.d.ts",
+      "default": "./dist/lib/neutral/Trace.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -27,23 +31,24 @@
     "src"
   ],
   "dependencies": {
-    "@effect/ai-anthropic": "0.22.0",
-    "@effect/platform": "0.93.6",
-    "effect": "3.19.11",
-    "@dxos/context": "0.8.4-main.bc674ce",
-    "@dxos/ai": "0.8.4-main.bc674ce",
-    "@dxos/echo": "0.8.4-main.bc674ce",
-    "@dxos/echo-db": "0.8.4-main.bc674ce",
-    "@dxos/effect": "0.8.4-main.bc674ce",
-    "@dxos/errors": "0.8.4-main.bc674ce",
-    "@dxos/keys": "0.8.4-main.bc674ce",
-    "@dxos/invariant": "0.8.4-main.bc674ce",
-    "@dxos/log": "0.8.4-main.bc674ce",
-    "@dxos/node-std": "0.8.4-main.bc674ce",
-    "@dxos/operation": "0.8.4-main.bc674ce",
-    "@dxos/protocols": "0.8.4-main.bc674ce",
-    "@dxos/schema": "0.8.4-main.bc674ce",
-    "@dxos/types": "0.8.4-main.bc674ce"
+    "@effect-atom/atom": "^0.5.1",
+    "@effect/ai-anthropic": "0.23.0",
+    "@effect/platform": "0.94.4",
+    "effect": "3.20.0",
+    "@dxos/ai": "0.8.4-main.bcb3aa67d6",
+    "@dxos/context": "0.8.4-main.bcb3aa67d6",
+    "@dxos/echo-db": "0.8.4-main.bcb3aa67d6",
+    "@dxos/echo": "0.8.4-main.bcb3aa67d6",
+    "@dxos/errors": "0.8.4-main.bcb3aa67d6",
+    "@dxos/keys": "0.8.4-main.bcb3aa67d6",
+    "@dxos/invariant": "0.8.4-main.bcb3aa67d6",
+    "@dxos/effect": "0.8.4-main.bcb3aa67d6",
+    "@dxos/log": "0.8.4-main.bcb3aa67d6",
+    "@dxos/node-std": "0.8.4-main.bcb3aa67d6",
+    "@dxos/operation": "0.8.4-main.bcb3aa67d6",
+    "@dxos/protocols": "0.8.4-main.bcb3aa67d6",
+    "@dxos/types": "0.8.4-main.bcb3aa67d6",
+    "@dxos/schema": "0.8.4-main.bcb3aa67d6"
   },
   "publishConfig": {
     "access": "public"

package/src/Trace.ts

@@ -0,0 +1,162 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import { Annotation, Obj, Type } from '@dxos/echo';
+import * as Layer from 'effect/Layer';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+/**
+ * Writes ephemeral or persistent events to the trace.
+ * Exposed to processes and operations to record events to the trace.
+ */
+export interface TraceWriter {
+  write<T>(eventType: EventType<T>, payload: NoInfer<T>): void;
+}
+
+/**
+ * Service that writes events to the trace.
+ * Exposed to processes and operations to record events to the trace.
+ */
+export class TraceService extends Context.Tag('@dxos/functions/TraceService')<TraceService, TraceWriter>() {}
+
+/**
+ * Writes an event to the trace.
+ */
+export const write: <T>(eventType: EventType<T>, payload: NoInfer<T>) => Effect.Effect<void, never, TraceService> =
+  Effect.serviceFunction(TraceService, (_) => _.write);
+
+/**
+ * Defines an event type for the trace.
+ */
+export interface EventType<T> {
+  readonly key: string;
+  readonly schema: Schema.Schema<T, any>;
+  readonly isEphemeral: boolean;
+}
+
+export const EventType = <T>(
+  key: string,
+  opts: { schema: Schema.Schema<T, any>; isEphemeral: boolean },
+): EventType<T> => {
+  return {
+    key,
+    schema: opts.schema,
+    isEphemeral: opts.isEphemeral,
+  };
+};
+
+/**
+ * Extracts the payload type from an event type.
+ */
+export type PayloadType<E extends EventType<any>> = E extends EventType<infer T> ? T : never;
+
+export const Event = Schema.Struct({
+  timestamp: Schema.Number,
+  type: Schema.String,
+  data: Schema.Unknown, // Type-specific payload;
+});
+export interface Event extends Schema.Schema.Type<typeof Event> {}
+
+/**
+ * Checks if an event is of a given type.
+ */
+export const isOfType = <T, E extends Event>(eventType: EventType<T>, event: E): event is E & { data: T } => {
+  return event.type === eventType.key;
+};
+
+/**
+ * Metadata on the context of a trace message.
+ */
+// TODO(dmaretskyi): Expand on this: conversation id, tool call id, etc.
+export const Meta = Schema.Struct({
+  pid: Schema.optional(Schema.String), // NOTE: Not Process.ID to avoid circular dependency.
+  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),
+});
+export interface Meta extends Schema.Schema.Type<typeof Meta> {}
+
+/**
+ * Envelope for a set of events.
+ */
+export const MessageData = Schema.Struct({
+  meta: Meta,
+
+  isEphemeral: Schema.Boolean,
+  events: Schema.Array(Event),
+});
+export interface MessageData extends Schema.Schema.Type<typeof MessageData> {}
+
+export const Message = MessageData.pipe(
+  Type.object({
+    typename: 'org.dxos.type.traceMessage',
+    version: '0.1.0',
+  }),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--note--regular',
+    hue: 'rose',
+  }),
+);
+export interface Message extends Schema.Schema.Type<typeof Message> {}
+
+/**
+ * Sink for complete trace messages.
+ */
+export interface Sink {
+  write(message: Message): void;
+}
+
+/**
+ * Sink for complete trace messages.
+ * The Process Manager forwards trace messages to it.
+ */
+// TODO(dmaretskyi): Consider moving sink to the Process Manager.
+export class TraceSink extends Context.Tag('@dxos/functions/TraceSink')<TraceSink, Sink>() {}
+
+export const noopWriter: TraceWriter = {
+  write: () => {},
+};
+
+export const writerLayerNoop: Layer.Layer<TraceService> = Layer.succeed(TraceService, noopWriter);
+
+export const layerNoop: Layer.Layer<TraceSink> = Layer.succeed(TraceSink, {
+  write: () => {},
+});
+
+export const layerConsole: Layer.Layer<TraceSink> = Layer.succeed(TraceSink, {
+  write: (message) => {
+    console.log(message);
+  },
+});
+
+export const testTraceService = (opts: { meta?: Meta } = {}): Layer.Layer<TraceService, never, TraceSink> =>
+  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 }],
+            }),
+          );
+        },
+      };
+    }),
+  );

package/src/errors.ts

@@ -6,7 +6,7 @@ import { BaseError, type BaseErrorOptions } from '@dxos/errors';
 
 export class ServiceNotAvailableError extends BaseError.extend('ServiceNotAvailable', 'Service not available') {
   constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>) {
-    super({ context: { service }, ...options });
+    super({ context: { service }, ...options, message: `Service not available: ${service}` });
   }
 }
 

package/src/example/definitions.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Operation } from '@dxos/operation';
+import * as Schema from 'effect/Schema';
+
+export const 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: 100_000,
+    }),
+  }),
+  output: Schema.Struct({
+    result: Schema.String,
+  }),
+});
+
+export const Reply = Operation.make({
+  meta: {
+    key: 'example.org/function/reply',
+    name: 'Reply',
+    description: 'Function that echoes the input',
+  },
+  input: Schema.Any,
+  output: Schema.Any,
+});
+
+export const 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: 100_000,
+    }),
+  }),
+  output: Schema.Void,
+});

package/src/example/fib.ts

@@ -3,30 +3,20 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '../sdk';
+import { Operation } from '@dxos/operation';
+import { Fibonacci } from './definitions';
 
-export default defineFunction({
-  key: 'example.org/function/fib',
-  name: 'Fibonacci',
-  description: 'Function that calculates a Fibonacci number',
-  inputSchema: Schema.Struct({
-    iterations: Schema.optional(Schema.Number).annotations({
-      description: 'Number of iterations',
-      default: 100_000,
+export default Fibonacci.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ iterations = 100_000 }) {
+      let a = 0n;
+      let b = 1n;
+      for (let i = 0; i < iterations; i++) {
+        a += b;
+        b = a - b;
+      }
+      return { result: a.toString() };
     }),
-  }),
-  outputSchema: Schema.Struct({
-    result: Schema.String,
-  }),
-  handler: Effect.fn(function* ({ data: { iterations = 100_000 } }) {
-    let a = 0n;
-    let b = 1n;
-    for (let i = 0; i < iterations; i++) {
-      a += b;
-      b = a - b;
-    }
-    return { result: a.toString() };
-  }),
-});
+  ),
+);

package/src/example/forex-effect.ts

@@ -14,7 +14,7 @@ import {
 import { Effect, Schedule } from 'https://esm.sh/effect@3.17.0?bundle=false';
 
 export default defineFunction({
-  key: 'dxos.org/script/forex-effect',
+  key: 'org.dxos.script.forex-effect',
   name: 'Forex Effect',
   description: 'Returns the exchange rate between two currencies.',
 

package/src/example/index.ts

@@ -2,12 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { default as fib$ } from './fib';
-import { default as reply$ } from './reply';
-import { default as sleep$ } from './sleep';
+import { OperationHandlerSet } from '@dxos/operation';
+export * from './definitions';
 
-export namespace Example {
-  export const fib = fib$;
-  export const reply = reply$;
-  export const sleep = sleep$;
-}
+export const ExampleHandlers = OperationHandlerSet.lazy(
+  () => import('./fib'),
+  () => import('./reply'),
+  () => import('./sleep'),
+);

package/src/example/reply.ts

@@ -4,18 +4,15 @@
 
 import * as Console from 'effect/Console';
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '../sdk';
+import { Operation } from '@dxos/operation';
+import { Reply } from './definitions';
 
-export default defineFunction({
-  key: 'example.org/function/reply',
-  name: 'Reply',
-  description: 'Function that echoes the input',
-  inputSchema: Schema.Any,
-  outputSchema: Schema.Any,
-  handler: Effect.fn(function* ({ data }) {
-    yield* Console.log('reply', { data });
-    return data;
-  }),
-});
+export default Reply.pipe(
+  Operation.withHandler(
+    Effect.fn(function* (input) {
+      yield* Console.log('reply', { input });
+      return input;
+    }),
+  ),
+);

package/src/example/sleep.ts

@@ -3,22 +3,13 @@
 //
 
 import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
+import { Sleep } from './definitions';
+import { Operation } from '@dxos/operation';
 
-import { defineFunction } from '../sdk';
-
-export default defineFunction({
-  key: 'example.org/function/sleep',
-  name: 'Sleep',
-  description: 'Function that sleeps for a given amount of time',
-  inputSchema: Schema.Struct({
-    duration: Schema.optional(Schema.Number).annotations({
-      description: 'Milliseconds to sleep',
-      default: 100_000,
+export default Sleep.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ duration = 100_000 }) {
+      yield* Effect.sleep(duration);
     }),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { duration = 100_000 } }) {
-    yield* Effect.sleep(duration);
-  }),
-});
+  ),
+);

package/src/index.ts

@@ -4,7 +4,11 @@
 
 export * from './errors';
 export * from './example';
+export * as Process from './process/Process';
+export * as ServiceResolver from './process/ServiceResolver';
+export * from './process/StorageService';
 export * from './sdk';
 export * from './services';
 export * from './types';
 export * from './protocol';
+export * as Trace from './Trace';