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

package/src/process/StorageService.ts

@@ -0,0 +1,99 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Pipeable from 'effect/Pipeable';
+import * as Schema from 'effect/Schema';
+
+export interface Service {
+  /** Read a value by key. Returns `None` if key does not exist. */
+  get<S extends Schema.Schema<any, string, any>>(
+    schema: S,
+    key: string,
+  ): Effect.Effect<Option.Option<Schema.Schema.Type<S>>, never, Schema.Schema.Context<S>>;
+
+  /** Write a value for the given key. */
+  set<S extends Schema.Schema<any, string, any>>(
+    schema: S,
+    key: string,
+    value: Schema.Schema.Type<S>,
+  ): Effect.Effect<void, never, Schema.Schema.Context<S>>;
+
+  /** Remove a key. */
+  delete(key: string): Effect.Effect<void>;
+
+  /** List all keys, optionally filtered by prefix. */
+  list(prefix?: string): Effect.Effect<readonly string[]>;
+
+  /** Remove all keys managed by this scoped store. */
+  clear(): Effect.Effect<void>;
+}
+
+/**
+ * Scoped key-value storage service for processes.
+ * Each process receives its own namespaced instance via the process manager.
+ * Construct a live implementation with `StorageService.layer` from `@dxos/functions-runtime`.
+ */
+export class StorageService extends Context.Tag('@dxos/functions/StorageService')<StorageService, Service>() {}
+
+export const get = Effect.serviceFunctionEffect(StorageService, (_) => _.get);
+export const set = Effect.serviceFunctionEffect(StorageService, (_) => _.set);
+export const deleteKey = Effect.serviceFunctionEffect(StorageService, (_) => _.delete);
+export const list = Effect.serviceFunctionEffect(StorageService, (_) => _.list);
+export const clear = Effect.serviceFunctionEffect(StorageService, (_) => _.clear);
+
+/**
+ * Typed key in a storage service.
+ */
+export interface Key<T> extends Pipeable.Pipeable {
+  readonly key: string;
+
+  get: Effect.Effect<Option.Option<T>, never, StorageService>;
+  set(value: T): Effect.Effect<void, never, StorageService>;
+  delete(): Effect.Effect<void, never, StorageService>;
+}
+
+/**
+ * Create a typed key in a storage service.
+ */
+export const key = <S extends Schema.Schema<any, string, any>>(schema: S, key: string): Key<Schema.Schema.Type<S>> => {
+  return {
+    key,
+    get: get(schema, key),
+    set: (value: Schema.Schema.Type<S>) => set(schema, key, value),
+    delete: () => deleteKey(key),
+    pipe(...args: any) {
+      return Pipeable.pipeArguments(this, arguments);
+    },
+  };
+};
+
+/**
+ * Typed key in a storage service with a default value.
+ */
+export interface KeyWithDefault<T, U> extends Pipeable.Pipeable {
+  readonly key: string;
+  get: Effect.Effect<T | U, never, StorageService>;
+  set(value: U): Effect.Effect<void, never, StorageService>;
+  delete(): Effect.Effect<void, never, StorageService>;
+}
+
+/**
+ * Assign a default value to a key if it is not present.
+ */
+export const withDefault =
+  <T>(getDefault: () => NoInfer<T>) =>
+  (key: Key<T>): KeyWithDefault<T, T> => {
+    return {
+      key: key.key,
+      get: key.get.pipe(Effect.map(Option.getOrElse(() => getDefault()))),
+      set: (value) => key.set(value),
+      delete: () => key.delete(),
+      pipe(...args: any) {
+        return Pipeable.pipeArguments(this, arguments);
+      },
+    };
+  };

package/src/protocol/protocol.test.ts

@@ -7,7 +7,6 @@ import { describe, test } from 'vitest';
 import { FunctionError } from '../errors';
 import fibFunc from '../example/fib';
 import replyFunc from '../example/reply';
-
 import { wrapFunctionHandler } from './protocol';
 
 describe('wrapFunctionHandler', () => {

package/src/protocol/protocol.ts

@@ -11,40 +11,45 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { AiModelResolver, AiService } from '@dxos/ai';
 import { AnthropicResolver } from '@dxos/ai/resolvers';
 import { LifecycleState, Resource } from '@dxos/context';
-import { Database, Ref, Type } from '@dxos/echo';
+import { Database, Feed, JsonSchema, Ref, type Type } from '@dxos/echo';
+import { EchoClient, type EchoDatabaseImpl, type QueueFactory, createFeedServiceLayer } from '@dxos/echo-db';
 import { refFromEncodedReference } from '@dxos/echo/internal';
-import { EchoClient, type EchoDatabaseImpl, type QueueFactory } from '@dxos/echo-db';
 import { runAndForwardErrors } from '@dxos/effect';
 import { assertState, failedInvariant, invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
+import { Operation } from '@dxos/operation';
 import { type FunctionProtocol } from '@dxos/protocols';
 
 import { FunctionError } from '../errors';
-import { FunctionDefinition, type FunctionServices } from '../sdk';
+import { type FunctionServices } from '../sdk';
 import { CredentialsService, FunctionInvocationService, QueueService, TracingService } from '../services';
-
+import * as Trace from '../Trace';
 import { FunctionsAiHttpClient } from './functions-ai-http-client';
 
 /**
  * Wraps a function handler made with `defineFunction` to a protocol that the functions-runtime expects.
  */
-export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.Func => {
-  if (!FunctionDefinition.isFunction(func)) {
-    throw new TypeError('Invalid function definition');
+export const wrapFunctionHandler = (func: Operation.WithHandler<Operation.Definition.Any>): FunctionProtocol.Func => {
+  if (!Operation.isOperationWithHandler(func)) {
+    throw new TypeError('Expected operation with handler');
   }
 
+  const serviceTags = func.services.map((service) => service.key);
+
   return {
     meta: {
-      key: func.key,
-      name: func.name,
-      description: func.description,
-      inputSchema: Type.toJsonSchema(func.inputSchema),
-      outputSchema: func.outputSchema === undefined ? undefined : Type.toJsonSchema(func.outputSchema),
-      services: func.services,
+      key: func.meta.key,
+      name: func.meta.name,
+      description: func.meta.description,
+      inputSchema: JsonSchema.toJsonSchema(func.input),
+      outputSchema: func.output === undefined ? undefined : JsonSchema.toJsonSchema(func.output),
+      services: func.services.map((service) => service.key),
     },
     handler: async ({ data, context }) => {
       if (
-        (func.services.includes(Database.Service.key) || func.services.includes(QueueService.key)) &&
+        (serviceTags.includes(Database.Service.key) ||
+          serviceTags.includes(QueueService.key) ||
+          serviceTags.includes(Feed.FeedService.key)) &&
         (!context.services.dataService || !context.services.queryService)
       ) {
         throw new FunctionError({
@@ -54,9 +59,9 @@ export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.
 
       // eslint-disable-next-line no-useless-catch
       try {
-        if (!SchemaAST.isAnyKeyword(func.inputSchema.ast)) {
+        if (!SchemaAST.isAnyKeyword(func.input.ast)) {
           try {
-            Schema.validateSync(func.inputSchema)(data);
+            Schema.validateSync(func.input)(data);
           } catch (error) {
             throw new FunctionError({ message: 'Invalid input schema', cause: error });
           }
@@ -66,19 +71,15 @@ export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.
 
         if (func.types.length > 0) {
           invariant(funcContext.db, 'Database is required for functions with types');
-          await funcContext.db.graph.schemaRegistry.register(func.types as Type.Entity.Any[]);
+          await funcContext.db.graph.schemaRegistry.register(func.types as Type.AnyEntity[]);
         }
 
         const dataWithDecodedRefs =
-          funcContext.db && !SchemaAST.isAnyKeyword(func.inputSchema.ast)
-            ? decodeRefsFromSchema(func.inputSchema.ast, data, funcContext.db)
+          funcContext.db && !SchemaAST.isAnyKeyword(func.input.ast)
+            ? decodeRefsFromSchema(func.input.ast, data, funcContext.db)
             : data;
 
-        let result = await func.handler({
-          // TODO(dmaretskyi): Fix the types.
-          context: context as any,
-          data: dataWithDecodedRefs,
-        });
+        let result: any = await func.handler(dataWithDecodedRefs);
 
         if (Effect.isEffect(result)) {
           result = await runAndForwardErrors(
@@ -89,8 +90,8 @@ export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.
           );
         }
 
-        if (func.outputSchema && !SchemaAST.isAnyKeyword(func.outputSchema.ast)) {
-          Schema.validateSync(func.outputSchema)(result);
+        if (func.output && !SchemaAST.isAnyKeyword(func.output.ast)) {
+          Schema.validateSync(func.output)(result);
         }
 
         return result;
@@ -149,8 +150,9 @@ class FunctionContext extends Resource {
   createLayer(): Layer.Layer<FunctionServices> {
     assertState(this._lifecycleState === LifecycleState.OPEN, 'FunctionContext is not open');
 
-    const dbLayer = this.db ? Database.Service.layer(this.db) : Database.Service.notAvailable;
+    const dbLayer = this.db ? Database.layer(this.db) : Database.notAvailable;
     const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
+    const feedLayer = this.queues ? createFeedServiceLayer(this.queues) : Feed.notAvailable;
     const credentials = dbLayer
       ? CredentialsService.layerFromDatabase({ caching: true }).pipe(Layer.provide(dbLayer))
       : CredentialsService.configuredLayer([]);
@@ -173,12 +175,15 @@ class FunctionContext extends Resource {
       : AiService.notAvailable;
 
     return Layer.mergeAll(
-      dbLayer, //
+      dbLayer,
       queuesLayer,
+      feedLayer,
       credentials,
       functionInvocationService,
       aiLayer,
       tracing,
+      // TODO(dmaretskyi): Forward trace events.
+      Trace.writerLayerNoop,
     );
   }
 }

package/src/sdk.ts

@@ -2,15 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import type * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
 import { type AiService } from '@dxos/ai';
-import { Obj, Type } from '@dxos/echo';
-import { type Database } from '@dxos/echo';
-import { assertArgument, failedInvariant } from '@dxos/invariant';
-import { Operation } from '@dxos/operation';
+import { type Database, type Feed } from '@dxos/echo';
+import { type Trace } from '@dxos/functions';
 
 import {
   type CredentialsService,
@@ -18,8 +12,6 @@ import {
   type QueueService,
   type TracingService,
 } from './services';
-import { Function } from './types';
-import { getUserFunctionIdInMetadata, setUserFunctionIdInMetadata } from './types';
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
@@ -33,257 +25,15 @@ export type InvocationServices = TracingService;
 
 /**
  * Services that are available to invoked functions.
+ * @deprecated
  */
 export type FunctionServices =
   | InvocationServices
   | AiService.AiService
   | CredentialsService
   | Database.Service
+  // TODO(wittjosiah): Remove QueueService — use Feed.FeedService instead.
   | QueueService
+  | Feed.FeedService
+  | Trace.TraceService
   | FunctionInvocationService;
-
-/**
- * Function handler.
- */
-export type FunctionHandler<TData = {}, TOutput = any, S extends FunctionServices = FunctionServices> = (params: {
-  /**
-   * Context available to the function.
-   */
-  context: FunctionContext;
-
-  /**
-   * Data passed as the input to the function.
-   * Must match the function's input schema.
-   * This will be the payload from the trigger or other data passed into the function in a workflow.
-   */
-  data: TData;
-}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, S>;
-
-/**
- * Function context.
- */
-export interface FunctionContext {
-  // TODO(dmaretskyi): Consider what we should put into context.
-}
-
-const typeId = Symbol.for('@dxos/functions/FunctionDefinition');
-
-export type FunctionDefinition<T = any, O = any, S extends FunctionServices = FunctionServices> = {
-  [typeId]: true;
-  key: string;
-  name: string;
-  description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, any>;
-
-  /**
-   * List of types the function uses.
-   * This is used to ensure that the types are available when the function is executed.
-   */
-  types: readonly Type.Entity.Any[];
-
-  /**
-   * Keys of the required services.
-   */
-  services: readonly string[];
-
-  handler: FunctionHandler<T, O, S>;
-  meta?: {
-    /**
-     * Tools that are projected from functions have this annotation.
-     *
-     * deployedFunctionId:
-     * - Backend deployment ID assigned by the EDGE function service (typically a UUID).
-     * - Used for remote invocation via `FunctionInvocationService` → `RemoteFunctionExecutionService`.
-     * - Persisted on the corresponding ECHO `Function.Function` object's metadata under the
-     *   `FUNCTIONS_META_KEY` and retrieved with `getUserFunctionIdInMetadata`.
-     */
-    deployedFunctionId?: string;
-  };
-};
-
-export declare namespace FunctionDefinition {
-  export type Any = FunctionDefinition<any, any, any>;
-  export type Input<T extends Any> = T extends FunctionDefinition<infer I, infer _O, infer _S> ? I : never;
-  export type Output<T extends Any> = T extends FunctionDefinition<infer _I, infer O, infer _S> ? O : never;
-  export type Services<T extends Any> = T extends FunctionDefinition<infer _I, infer _O, infer S> ? S : never;
-}
-
-export type FunctionProps<T, O> = {
-  key: string;
-  name: string;
-  description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, any>;
-
-  /**
-   * List of types the function uses.
-   * This is used to ensure that the types are available when the function is executed.
-   */
-  types?: readonly Type.Entity.Any[];
-  // TODO(dmaretskyi): This currently doesn't cause a compile-time error if the handler requests a service that is not specified
-  services?: readonly Context.Tag<any, any>[];
-
-  handler: FunctionHandler<T, O, FunctionServices>;
-};
-
-// TODO(dmaretskyi): Output type doesn't get typechecked.
-export const defineFunction: {
-  <I, O>(params: FunctionProps<I, O>): FunctionDefinition<I, O, FunctionServices>;
-} = ({ key, name, description, inputSchema, outputSchema = Schema.Any, handler, types, services }) => {
-  if (!Schema.isSchema(inputSchema)) {
-    throw new Error('Input schema must be a valid schema');
-  }
-  if (typeof handler !== 'function') {
-    throw new Error('Handler must be a function');
-  }
-
-  // Captures the function definition location.
-  const limit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 2;
-  const traceError = new Error();
-  Error.stackTraceLimit = limit;
-  let cache: false | string = false;
-  const captureStackTrace = () => {
-    if (cache !== false) {
-      return cache;
-    }
-    if (traceError.stack !== undefined) {
-      const stack = traceError.stack.split('\n');
-      if (stack[2] !== undefined) {
-        cache = stack[2].trim();
-        return cache;
-      }
-    }
-  };
-
-  const handlerWithSpan = (...args: any[]) => {
-    const result = (handler as any)(...args);
-    if (Effect.isEffect(result)) {
-      return Effect.withSpan(result, `${key ?? name}`, {
-        captureStackTrace,
-      });
-    }
-    return result;
-  };
-
-  return {
-    [typeId]: true,
-    key,
-    name,
-    description,
-    inputSchema,
-    outputSchema,
-    handler: handlerWithSpan,
-    types: types ?? [],
-    services: !services ? [] : getServiceKeys(services),
-  } satisfies FunctionDefinition.Any;
-};
-
-const getServiceKeys = (services: readonly Context.Tag<any, any>[]) => {
-  return services.map((tag: any) => {
-    if (typeof tag.key === 'string') {
-      return tag.key;
-    }
-    failedInvariant();
-  });
-};
-
-/**
- * Converts a FunctionDefinition to an OperationDefinition with handler.
- * The function handler is adapted to the OperationHandler format.
- *
- * Note: FunctionDefinition stores service keys as strings, not Tag types,
- * so we can't use Operation.withHandler's type inference here.
- */
-export const toOperation = <T, O, S extends FunctionServices = FunctionServices>(
-  functionDef: FunctionDefinition<T, O, S>,
-): Operation.Definition<T, O> & { handler: Operation.Handler<T, O, any, S> } => {
-  const op = Operation.make({
-    schema: {
-      input: functionDef.inputSchema,
-      output: functionDef.outputSchema ?? Schema.Any,
-    },
-    meta: {
-      key: functionDef.key,
-      name: functionDef.name,
-      description: functionDef.description,
-    },
-  });
-
-  // Adapt FunctionHandler signature to OperationHandler format.
-  // FunctionHandler expects { context, data }, OperationHandler expects just input.
-  const operationHandler: Operation.Handler<T, O, any, S> = (input: T) => {
-    const result = functionDef.handler({
-      context: {} as FunctionContext,
-      data: input,
-    });
-
-    // Convert Promise or plain value to Effect.
-    if (Effect.isEffect(result)) {
-      return result;
-    }
-    if (result instanceof Promise) {
-      return Effect.tryPromise(() => result);
-    }
-    return Effect.succeed(result as O);
-  };
-
-  // Manually attach handler since FunctionDefinition stores service keys as strings,
-  // not Tag types, so withHandler's type inference doesn't apply.
-  return {
-    ...op,
-    handler: operationHandler,
-  };
-};
-
-export const FunctionDefinition = {
-  make: defineFunction,
-  isFunction: (value: unknown): value is FunctionDefinition.Any => {
-    return typeof value === 'object' && value !== null && Symbol.for('@dxos/functions/FunctionDefinition') in value;
-  },
-  serialize: (functionDef: FunctionDefinition.Any): Function.Function => {
-    assertArgument(FunctionDefinition.isFunction(functionDef), 'functionDef');
-    return serializeFunction(functionDef);
-  },
-  deserialize: (functionObj: Function.Function): FunctionDefinition.Any => {
-    assertArgument(Obj.instanceOf(Function.Function, functionObj), 'functionObj');
-    return deserializeFunction(functionObj);
-  },
-  toOperation,
-};
-
-export const serializeFunction = (functionDef: FunctionDefinition.Any): Function.Function => {
-  const fn = Function.make({
-    key: functionDef.key,
-    name: functionDef.name,
-    version: '0.1.0',
-    description: functionDef.description,
-    inputSchema: Type.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? undefined : Type.toJsonSchema(functionDef.outputSchema),
-    services: functionDef.services,
-  });
-  if (functionDef.meta?.deployedFunctionId) {
-    Obj.change(fn, (fn) => setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta!.deployedFunctionId!));
-  }
-  return fn;
-};
-
-export const deserializeFunction = (functionObj: Function.Function): FunctionDefinition<unknown, unknown> => {
-  return {
-    [typeId]: true,
-    // TODO(dmaretskyi): Fix key.
-    key: functionObj.key ?? functionObj.name,
-    name: functionObj.name,
-    description: functionObj.description,
-    inputSchema: !functionObj.inputSchema ? Schema.Unknown : Type.toEffectSchema(functionObj.inputSchema),
-    outputSchema: !functionObj.outputSchema ? undefined : Type.toEffectSchema(functionObj.outputSchema),
-    // TODO(dmaretskyi): This should throw error.
-    handler: () => {},
-    services: functionObj.services ?? [],
-    types: [],
-    meta: {
-      deployedFunctionId: getUserFunctionIdInMetadata(Obj.getMeta(functionObj)),
-    },
-  };
-};

package/src/services/event-logger.ts

@@ -52,7 +52,7 @@ export type ComputeEventPayload = Schema.Schema.Type<typeof ComputeEventPayload>
 
 export const ComputeEvent = Schema.Struct({
   payload: ComputeEventPayload,
-}).pipe(Type.object({ typename: 'dxos.org/type/ComputeEvent', version: '0.1.0' }));
+}).pipe(Type.object({ typename: 'org.dxos.type.computeEvent', version: '0.1.0' }));
 
 /**
  * Logs event for the compute workflows.

package/src/services/function-invocation-service.ts

@@ -5,18 +5,20 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
+import { Operation } from '@dxos/operation';
+
 import type { FunctionNotFoundError } from '../errors';
-import { type FunctionDefinition, type InvocationServices } from '../sdk';
+import { type InvocationServices } from '../sdk';
 
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
   FunctionInvocationService,
   {
     invokeFunction<I, O>(
-      functionDef: FunctionDefinition<I, O, any>,
+      functionDef: Operation.Definition<I, O, any>,
       input: I,
     ): Effect.Effect<O, never, InvocationServices>;
 
-    resolveFunction(key: string): Effect.Effect<FunctionDefinition.Any, FunctionNotFoundError>;
+    resolveFunction(key: string): Effect.Effect<Operation.Definition.Any, FunctionNotFoundError>;
   }
 >() {
   static layerNotAvailable = Layer.succeed(FunctionInvocationService, {
@@ -25,13 +27,13 @@ export class FunctionInvocationService extends Context.Tag('@dxos/functions/Func
   });
 
   static invokeFunction = <I, O>(
-    functionDef: FunctionDefinition<I, O, any>,
+    functionDef: Operation.Definition<I, O, any>,
     input: I,
   ): Effect.Effect<O, never, FunctionInvocationService | InvocationServices> =>
     Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
 
   static resolveFunction = (
     key: string,
-  ): Effect.Effect<FunctionDefinition.Any, FunctionNotFoundError, FunctionInvocationService> =>
+  ): Effect.Effect<Operation.Definition.Any, FunctionNotFoundError, FunctionInvocationService> =>
     Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.resolveFunction)(key);
 }

package/src/services/queues.ts

@@ -6,12 +6,13 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import type { Entity } from '@dxos/echo';
-import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
+import { type Entity } from '@dxos/echo';
+import { createFeedServiceLayer, type Queue, type QueueAPI, type QueueFactory } from '@dxos/echo-db';
 import type { DXN, QueueSubspaceTag } from '@dxos/keys';
 
 /**
  * Gives access to all queues.
+ * @deprecated Use Feed.FeedService instead.
  */
 export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
   QueueService,
@@ -71,6 +72,7 @@ export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
 
 /**
  * Gives access to a specific queue passed as a context.
+ * @deprecated Use Feed.FeedService instead.
  */
 export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQueueService')<
   ContextQueueService,
@@ -80,3 +82,10 @@ export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQue
 >() {
   static layer = (queue: Queue) => Layer.succeed(ContextQueueService, { queue });
 }
+
+export const feedServiceFromQueueServiceLayer = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const { queues } = yield* QueueService;
+    return createFeedServiceLayer(queues);
+  }),
+);