@dxos/functions 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/src/Trace.ts

@@ -1,202 +0,0 @@
-//
-// 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),
-});
-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,
-});

package/src/errors.ts

@@ -1,21 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-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, message: `Service not available: ${service}` });
-  }
-}
-
-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('FunctionError', 'Function invocation error') {}
-
-export class TriggerStateNotFoundError extends BaseError.extend('TriggerStateNotFound', 'Trigger state not found') {}

package/src/example/definitions.ts

@@ -1,49 +0,0 @@
-//
-// 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

@@ -1,23 +0,0 @@
-//
-// 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

@@ -1,40 +0,0 @@
-//
-// 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

@@ -1,12 +0,0 @@
-//
-// 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

@@ -1,19 +0,0 @@
-//
-// 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

@@ -1,17 +0,0 @@
-//
-// 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);
-    }),
-  ),
-);