@dxos/functions 0.8.4-main.406dc2a → 0.8.4-main.422d1c7879

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.406dc2a",
-  "description": "Functions API and runtime.",
+  "version": "0.8.4-main.422d1c7879",
+  "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "info@dxos.org",
   "sideEffects": false,
@@ -12,76 +16,39 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
-    },
-    "./bundler": {
-      "source": "./src/bundler/index.ts",
-      "types": "./dist/types/src/bundler/index.d.ts",
-      "browser": "./dist/lib/browser/bundler/index.mjs",
-      "node": "./dist/lib/node-esm/bundler/index.mjs"
-    },
-    "./edge": {
-      "source": "./src/edge/index.ts",
-      "types": "./dist/types/src/edge/index.d.ts",
-      "browser": "./dist/lib/browser/edge/index.mjs",
-      "node": "./dist/lib/node-esm/edge/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     },
-    "./testing": {
-      "source": "./src/testing/index.ts",
-      "types": "./dist/types/src/testing/index.d.ts",
-      "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/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",
-  "typesVersions": {
-    "*": {
-      "bundler": [
-        "dist/types/src/bundler/index.d.ts"
-      ],
-      "edge": [
-        "dist/types/src/edge/index.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist",
     "schema",
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.92.1",
-    "effect": "3.18.3",
-    "esbuild-wasm": "^0.16.14",
-    "i18next": "^24.2.1",
-    "iso-did": "^1.6.0",
-    "@dxos/ai": "0.8.4-main.406dc2a",
-    "@dxos/async": "0.8.4-main.406dc2a",
-    "@dxos/client": "0.8.4-main.406dc2a",
-    "@dxos/client-protocol": "0.8.4-main.406dc2a",
-    "@dxos/context": "0.8.4-main.406dc2a",
-    "@dxos/crypto": "0.8.4-main.406dc2a",
-    "@dxos/debug": "0.8.4-main.406dc2a",
-    "@dxos/echo-db": "0.8.4-main.406dc2a",
-    "@dxos/echo-protocol": "0.8.4-main.406dc2a",
-    "@dxos/edge-client": "0.8.4-main.406dc2a",
-    "@dxos/echo-pipeline": "0.8.4-main.406dc2a",
-    "@dxos/echo": "0.8.4-main.406dc2a",
-    "@dxos/effect": "0.8.4-main.406dc2a",
-    "@dxos/errors": "0.8.4-main.406dc2a",
-    "@dxos/invariant": "0.8.4-main.406dc2a",
-    "@dxos/keys": "0.8.4-main.406dc2a",
-    "@dxos/kv-store": "0.8.4-main.406dc2a",
-    "@dxos/log": "0.8.4-main.406dc2a",
-    "@dxos/node-std": "0.8.4-main.406dc2a",
-    "@dxos/protocols": "0.8.4-main.406dc2a",
-    "@dxos/live-object": "0.8.4-main.406dc2a",
-    "@dxos/schema": "0.8.4-main.406dc2a",
-    "@dxos/util": "0.8.4-main.406dc2a"
-  },
-  "devDependencies": {
-    "@dxos/agent": "0.8.4-main.406dc2a"
+    "@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.422d1c7879",
+    "@dxos/context": "0.8.4-main.422d1c7879",
+    "@dxos/echo": "0.8.4-main.422d1c7879",
+    "@dxos/echo-db": "0.8.4-main.422d1c7879",
+    "@dxos/errors": "0.8.4-main.422d1c7879",
+    "@dxos/invariant": "0.8.4-main.422d1c7879",
+    "@dxos/effect": "0.8.4-main.422d1c7879",
+    "@dxos/keys": "0.8.4-main.422d1c7879",
+    "@dxos/log": "0.8.4-main.422d1c7879",
+    "@dxos/operation": "0.8.4-main.422d1c7879",
+    "@dxos/protocols": "0.8.4-main.422d1c7879",
+    "@dxos/types": "0.8.4-main.422d1c7879",
+    "@dxos/node-std": "0.8.4-main.422d1c7879",
+    "@dxos/schema": "0.8.4-main.422d1c7879"
   },
   "publishConfig": {
     "access": "public"

package/src/Trace.ts

@@ -0,0 +1,225 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+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';
+
+/**
+ * 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),
+
+  /**
+   * ID of the tool call that created the current process.
+   */
+  toolCallId: Schema.optional(Schema.String),
+});
+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 }],
+            }),
+          );
+        },
+      };
+    }),
+  );
+
+//
+// Operation Trace Events
+//
+
+/**
+ * Outcome of an operation invocation.
+ */
+export type OperationOutcome = 'success' | 'failure';
+
+/**
+ * Operation invocation started.
+ */
+export const OperationStart = EventType('operation.start', {
+  schema: Schema.Struct({
+    /** Operation key. */
+    key: Schema.String,
+    /** Human-readable operation name. */
+    name: Schema.optional(Schema.String),
+  }),
+  isEphemeral: false,
+});
+
+/**
+ * Operation invocation ended.
+ */
+export const 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,
+});
+
+/**
+ * Human-readable status update emitted by an agent or operation.
+ */
+export const StatusUpdate = EventType('status.update', {
+  schema: Schema.Struct({
+    /** Human-readable status message. */
+    message: Schema.String,
+  }),
+  isEphemeral: true,
+});
+
+/**
+ * Emit the current human-readable execution status to the trace.
+ */
+export const emitStatus: (message: string) => Effect.Effect<void, never, TraceService> = (message) =>
+  write(StatusUpdate, { message });

package/src/errors.ts

@@ -4,18 +4,18 @@
 
 import { BaseError, type BaseErrorOptions } from '@dxos/errors';
 
-export class ServiceNotAvailableError extends BaseError.extend('SERVICE_NOT_AVAILABLE', 'Service not available') {
+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}` });
   }
 }
 
-export class FunctionNotFoundError extends BaseError.extend('FUNCTION_NOT_FOUND', 'Function not found') {
+export class FunctionNotFoundError extends BaseError.extend('FunctionNotFound', 'Function not found') {
   constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>) {
     super({ context: { function: functionKey }, ...options });
   }
 }
 
-export class FunctionError extends BaseError.extend('FUNCTION_ERROR', 'Function invocation error') {}
+export class FunctionError extends BaseError.extend('FunctionError', 'Function invocation error') {}
 
-export class TriggerStateNotFoundError extends BaseError.extend('TRIGGER_STATE_NOT_FOUND', 'Trigger state not found') {}
+export class TriggerStateNotFoundError extends BaseError.extend('TriggerStateNotFound', 'Trigger state not found') {}

package/src/example/definitions.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Operation } from '@dxos/operation';
+
+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

@@ -0,0 +1,23 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/operation';
+
+import { Fibonacci } from './definitions';
+
+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() };
+    }),
+  ),
+);

package/src/example/forex-effect.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @ts-ignore
+import { S, defineFunction } from 'dxos:functions';
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest,
+  // @ts-ignore
+} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
+// @ts-ignore
+import { Effect, Schedule } from 'https://esm.sh/effect@3.17.0?bundle=false';
+
+export default defineFunction({
+  key: 'org.dxos.script.forex-effect',
+  name: 'Forex Effect',
+  description: 'Returns the exchange rate between two currencies.',
+
+  inputSchema: S.Struct({
+    from: S.String.annotations({ description: 'The source currency' }),
+    to: S.String.annotations({ description: 'The target currency' }),
+  }),
+
+  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
+
+  handler: async ({ data: { from, to } }: any) =>
+    Effect.gen(function* () {
+      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+        HttpClient.execute,
+        Effect.flatMap((res: any) => res.json),
+        Effect.timeout('1 second'),
+        Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+        Effect.scoped,
+      );
+
+      return res.data.rates[to].toString();
+    }).pipe(Effect.provide(FetchHttpClient.layer)),
+});

package/src/example/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+export * from './definitions';
+
+export const ExampleHandlers = OperationHandlerSet.lazy(
+  () => import('./fib'),
+  () => import('./reply'),
+  () => import('./sleep'),
+);

package/src/example/reply.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/operation';
+
+import { Reply } from './definitions';
+
+export default Reply.pipe(
+  Operation.withHandler(
+    Effect.fn(function* (input) {
+      yield* Console.log('reply', { input });
+      return input;
+    }),
+  ),
+);

package/src/example/sleep.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/operation';
+
+import { Sleep } from './definitions';
+
+export default Sleep.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ duration = 100_000 }) {
+      yield* Effect.sleep(duration);
+    }),
+  ),
+);

package/src/index.ts

@@ -3,12 +3,12 @@
 //
 
 export * from './errors';
-export * from './handler';
-export * from './schema';
-export * from './trace';
-export * from './types';
-export * from './url';
-export * from './triggers';
+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 './executor';
-export * as exampleFunctions from './examples';
+export * from './types';
+export * from './protocol';
+export * as Trace from './Trace';