@dxos/functions 0.8.4-main.e098934 → 0.8.4-main.ead640a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.e098934",
+  "version": "0.8.4-main.ead640a",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -51,46 +51,37 @@
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.90.2",
-    "@preact/signals-core": "^1.9.0",
-    "cron": "^3.1.6",
-    "cron-schedule": "^5.0.4",
-    "effect": "3.17.7",
+    "@effect/platform": "0.92.1",
+    "effect": "3.18.3",
     "esbuild-wasm": "^0.16.14",
-    "express": "^4.19.2",
-    "get-port-please": "^3.1.1",
     "i18next": "^24.2.1",
     "iso-did": "^1.6.0",
-    "ws": "^8.14.2",
-    "@dxos/ai": "0.8.4-main.e098934",
-    "@dxos/client": "0.8.4-main.e098934",
-    "@dxos/async": "0.8.4-main.e098934",
-    "@dxos/client-protocol": "0.8.4-main.e098934",
-    "@dxos/context": "0.8.4-main.e098934",
-    "@dxos/debug": "0.8.4-main.e098934",
-    "@dxos/crypto": "0.8.4-main.e098934",
-    "@dxos/echo-db": "0.8.4-main.e098934",
-    "@dxos/echo-pipeline": "0.8.4-main.e098934",
-    "@dxos/echo": "0.8.4-main.e098934",
-    "@dxos/echo-protocol": "0.8.4-main.e098934",
-    "@dxos/echo-schema": "0.8.4-main.e098934",
-    "@dxos/edge-client": "0.8.4-main.e098934",
-    "@dxos/effect": "0.8.4-main.e098934",
-    "@dxos/errors": "0.8.4-main.e098934",
-    "@dxos/invariant": "0.8.4-main.e098934",
-    "@dxos/keys": "0.8.4-main.e098934",
-    "@dxos/live-object": "0.8.4-main.e098934",
-    "@dxos/kv-store": "0.8.4-main.e098934",
-    "@dxos/log": "0.8.4-main.e098934",
-    "@dxos/node-std": "0.8.4-main.e098934",
-    "@dxos/protocols": "0.8.4-main.e098934",
-    "@dxos/schema": "0.8.4-main.e098934",
-    "@dxos/util": "0.8.4-main.e098934"
+    "@dxos/ai": "0.8.4-main.ead640a",
+    "@dxos/async": "0.8.4-main.ead640a",
+    "@dxos/crypto": "0.8.4-main.ead640a",
+    "@dxos/client": "0.8.4-main.ead640a",
+    "@dxos/context": "0.8.4-main.ead640a",
+    "@dxos/debug": "0.8.4-main.ead640a",
+    "@dxos/echo": "0.8.4-main.ead640a",
+    "@dxos/echo-pipeline": "0.8.4-main.ead640a",
+    "@dxos/echo-db": "0.8.4-main.ead640a",
+    "@dxos/echo-protocol": "0.8.4-main.ead640a",
+    "@dxos/client-protocol": "0.8.4-main.ead640a",
+    "@dxos/edge-client": "0.8.4-main.ead640a",
+    "@dxos/invariant": "0.8.4-main.ead640a",
+    "@dxos/kv-store": "0.8.4-main.ead640a",
+    "@dxos/keys": "0.8.4-main.ead640a",
+    "@dxos/live-object": "0.8.4-main.ead640a",
+    "@dxos/effect": "0.8.4-main.ead640a",
+    "@dxos/errors": "0.8.4-main.ead640a",
+    "@dxos/node-std": "0.8.4-main.ead640a",
+    "@dxos/log": "0.8.4-main.ead640a",
+    "@dxos/schema": "0.8.4-main.ead640a",
+    "@dxos/util": "0.8.4-main.ead640a",
+    "@dxos/protocols": "0.8.4-main.ead640a"
   },
   "devDependencies": {
-    "@types/express": "^4.17.17",
-    "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.4-main.e098934"
+    "@dxos/agent": "0.8.4-main.ead640a"
   },
   "publishConfig": {
     "access": "public"

package/src/bundler/bundler.ts

@@ -2,8 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { FetchHttpClient, HttpClient } from '@effect/platform';
-import { Duration, Effect, Schedule, pipe } from 'effect';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Schedule from 'effect/Schedule';
 import { type BuildOptions, type BuildResult, type Loader, type Plugin, build, initialize } from 'esbuild-wasm';
 
 import { subtleCrypto } from '@dxos/crypto';
@@ -277,7 +281,7 @@ const httpPlugin: Plugin = {
         return { contents: text, loader: 'jsx' as Loader };
       }).pipe(
         Effect.retry(
-          pipe(
+          Function.pipe(
             Schedule.exponential(Duration.millis(INITIAL_DELAY)),
             Schedule.jittered,
             Schedule.intersect(Schedule.recurs(MAX_RETRIES - 1)),

package/src/examples/fib.ts

@@ -2,12 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
 import { defineFunction } from '../handler';
 
 export default defineFunction({
-  name: 'example.org/function/fib',
+  key: 'example.org/function/fib',
+  name: 'Fibonacci',
   description: 'Function that calculates a Fibonacci number',
   inputSchema: Schema.Struct({
     iterations: Schema.optional(Schema.Number).annotations({

package/src/examples/reply.ts

@@ -2,12 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Console, Effect, Schema } from 'effect';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
 import { defineFunction } from '../handler';
 
 export default defineFunction({
-  name: 'example.org/function/reply',
+  key: 'example.org/function/reply',
+  name: 'Reply',
   description: 'Function that echoes the input',
   inputSchema: Schema.Any,
   outputSchema: Schema.Any,

package/src/examples/sleep.ts

@@ -2,12 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
 import { defineFunction } from '../handler';
 
 export default defineFunction({
-  name: 'example.org/function/sleep',
+  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({

package/src/executor/executor.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
 
 import { type SpaceId } from '@dxos/client/echo';
 import { runAndForwardErrors } from '@dxos/effect';
@@ -10,6 +11,9 @@ import { runAndForwardErrors } from '@dxos/effect';
 import type { FunctionContext, FunctionDefinition } from '../handler';
 import type { ServiceContainer, Services } from '../services';
 
+/**
+ * @deprecated Use `FunctionInvocationService`
+ */
 export class FunctionExecutor {
   constructor(private readonly _services: ServiceContainer) {}
 

package/src/handler.ts

@@ -2,17 +2,21 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Context, Effect, Schema, type Types } from 'effect';
+import type * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import type * as Types from 'effect/Types';
 
 import { Obj, Type } from '@dxos/echo';
+import { type HasId } from '@dxos/echo/internal';
 import { type EchoDatabase } from '@dxos/echo-db';
-import { type HasId } from '@dxos/echo-schema';
 import { assertArgument } from '@dxos/invariant';
 import { type DXN, type SpaceId } from '@dxos/keys';
 import { type QueryResult } from '@dxos/protocols';
 
 import { FunctionType } from './schema';
 import { type Services } from './services';
+import { getUserFunctionIdInMetadata, setUserFunctionIdInMetadata } from './url';
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
@@ -90,19 +94,30 @@ const typeId = Symbol.for('@dxos/functions/FunctionDefinition');
 
 export type FunctionDefinition<T = any, O = any> = {
   [typeId]: true;
-  // TODO(dmaretskyi): Use `key` for FQN and `name` for human-readable-name.
   key: string;
   name: string;
   description?: string;
   inputSchema: Schema.Schema<T, any>;
   outputSchema?: Schema.Schema<O, any>;
   handler: FunctionHandler<T, O>;
+  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 `FunctionType` object's metadata under the
+     *   `FUNCTIONS_META_KEY` and retrieved with `getUserFunctionIdInMetadata`.
+     */
+    deployedFunctionId?: string;
+  };
 };
 
+// TODO(dmaretskyi): Output type doesn't get typechecked.
 export const defineFunction: {
   <I, O>(params: {
-    // TODO(dmaretskyi): Make `key` required.
-    key?: string;
+    key: string;
     name: string;
     description?: string;
     inputSchema: Schema.Schema<I, any>;
@@ -148,7 +163,7 @@ export const defineFunction: {
 
   return {
     [typeId]: true,
-    key: key ?? name,
+    key,
     name,
     description,
     inputSchema,
@@ -177,15 +192,20 @@ export declare namespace FunctionDefinition {
   export type Output<T extends FunctionDefinition> = T extends FunctionDefinition<any, infer O> ? O : never;
 }
 
-export const serializeFunction = (functionDef: FunctionDefinition<any, any>): FunctionType =>
-  Obj.make(FunctionType, {
-    key: functionDef.name,
+export const serializeFunction = (functionDef: FunctionDefinition<any, any>): FunctionType => {
+  const fn = Obj.make(FunctionType, {
+    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),
   });
+  if (functionDef.meta?.deployedFunctionId) {
+    setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta.deployedFunctionId);
+  }
+  return fn;
+};
 
 export const deserializeFunction = (functionObj: FunctionType): FunctionDefinition<unknown, unknown> => {
   return {
@@ -196,6 +216,10 @@ export const deserializeFunction = (functionObj: FunctionType): FunctionDefiniti
     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: () => {},
+    meta: {
+      deployedFunctionId: getUserFunctionIdInMetadata(Obj.getMeta(functionObj)),
+    },
   };
 };

package/src/schema.ts

@@ -2,12 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { Type } from '@dxos/echo';
-import { JsonSchemaType, LabelAnnotation, Ref } from '@dxos/echo-schema';
+import { JsonSchemaType, LabelAnnotation, Ref } from '@dxos/echo/internal';
 import { DataType } from '@dxos/schema';
 
+// TODO(burdon): Create namespace and remove Type suffix.
+
 /**
  * Source script.
  */
@@ -65,4 +67,5 @@ export const FunctionType = Schema.Struct({
   }),
   LabelAnnotation.set(['name']),
 );
+
 export interface FunctionType extends Schema.Schema.Type<typeof FunctionType> {}

package/src/services/credentials.ts

@@ -2,8 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { HttpClient, HttpClientRequest } from '@effect/platform';
-import { type Config, Context, Effect, Layer, Redacted } from 'effect';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import type * as Config from 'effect/Config';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Redacted from 'effect/Redacted';
 
 import { Query } from '@dxos/echo';
 import { DataType } from '@dxos/schema';
@@ -93,6 +98,7 @@ export class CredentialsService extends Context.Tag('@dxos/functions/Credentials
             if (credentials.length === 0) {
               throw new Error(`Credential not found for service: ${query.service}`);
             }
+
             return credentials[0];
           },
           queryCredentials: async (query) => {
@@ -120,6 +126,7 @@ export class ConfiguredCredentialsService implements Context.Tag.Service<Credent
     if (!credential) {
       throw new Error(`Credential not found for service: ${query.service}`);
     }
+
     return credential;
   }
 }

package/src/services/database.ts

@@ -2,7 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer, Option, type Schema } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
 
 import {
   type Filter,
@@ -14,9 +18,9 @@ import {
   type Relation,
   type Type,
 } from '@dxos/echo';
+import type { EchoSchema } from '@dxos/echo/internal';
 import type { EchoDatabase, FlushOptions, OneShotQueryResult, QueryResult, SchemaRegistryQuery } from '@dxos/echo-db';
 import type { SchemaRegistryPreparedQuery } from '@dxos/echo-db';
-import type { EchoSchema } from '@dxos/echo-schema';
 import { promiseWithCauseCapture } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import type { DXN } from '@dxos/keys';

package/src/services/event-logger.ts

@@ -2,7 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer, Schema } from 'effect';
+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 { Obj, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';

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

@@ -0,0 +1,81 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+
+import { AiService } from '@dxos/ai';
+
+import { defineFunction } from '../handler';
+import { TestDatabaseLayer } from '../testing';
+
+import { FunctionInvocationService } from './function-invocation-service';
+import { FunctionImplementationResolver } from './local-function-execution';
+
+const TestLayer = Layer.mergeAll(AiService.model('@anthropic/claude-opus-4-0')).pipe(
+  Layer.provideMerge(
+    Layer.mergeAll(
+      TestDatabaseLayer({
+        indexing: { vector: true },
+        types: [],
+      }),
+      FunctionInvocationService.layer,
+    ),
+  ),
+);
+
+describe('FunctionInvocationService', () => {
+  it(
+    'should be defined',
+    Effect.fnUntraced(function* () {
+      const service = yield* FunctionInvocationService;
+      expect(service).toBeDefined();
+    }, Effect.provide(TestLayer)),
+  );
+
+  it(
+    'routes to local when implementation is available',
+    Effect.fnUntraced(function* () {
+      const add = defineFunction({
+        key: 'example.org/function/add',
+        name: 'add',
+        inputSchema: Schema.Struct({ a: Schema.Number, b: Schema.Number }),
+        outputSchema: Schema.Number,
+        handler: ({ data }) => data.a + data.b,
+      });
+
+      const layer = TestLayer.pipe(Layer.provideMerge(FunctionImplementationResolver.layerTest({ functions: [add] })));
+
+      const result = yield* Effect.gen(function* () {
+        return yield* FunctionInvocationService.invokeFunction(add, { a: 2, b: 3 });
+      }).pipe(Effect.provide(layer));
+
+      expect(result).toEqual(5);
+    }),
+  );
+
+  it(
+    'routes to remote when no local implementation is found',
+    Effect.fnUntraced(function* () {
+      // This function is not deployed, so mock layer will be used.
+      const echo = defineFunction({
+        key: 'example.org/function/echo',
+        name: 'function-that-is-deployed',
+        inputSchema: Schema.Unknown,
+        outputSchema: Schema.Unknown,
+        handler: () => {},
+      });
+
+      // No resolver provided → resolveFunctionImplementation will fail → remote path is used.
+      const result = yield* Effect.gen(function* () {
+        return yield* FunctionInvocationService.invokeFunction(echo, { hello: 'world' });
+      }).pipe(Effect.provide(TestLayer));
+
+      // RemoteFunctionExecutionService.mock echos input back.
+      expect(result).toEqual({ hello: 'world', resolved: 'remote' });
+    }),
+  );
+});

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

@@ -0,0 +1,84 @@
+//
+// Copyright 2025 DXOS.org
+//
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { AiService } from '@dxos/ai';
+
+import { type FunctionDefinition } from '../handler';
+
+import { CredentialsService } from './credentials';
+import { DatabaseService } from './database';
+import {
+  FunctionImplementationResolver,
+  type InvocationServices,
+  LocalFunctionExecutionService,
+} from './local-function-execution';
+import { QueueService } from './queues';
+import { RemoteFunctionExecutionService } from './remote-function-execution-service';
+
+export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
+  FunctionInvocationService,
+  {
+    invokeFunction<I, O>(functionDef: FunctionDefinition<I, O>, input: I): Effect.Effect<O, never, InvocationServices>;
+  }
+>() {
+  static invokeFunction = Effect.serviceFunctionEffect(FunctionInvocationService, (_) => _.invokeFunction);
+
+  static layer = Layer.effect(
+    FunctionInvocationService,
+    Effect.gen(function* () {
+      const localExecutioner = yield* LocalFunctionExecutionService;
+      const remoteExecutioner = yield* RemoteFunctionExecutionService;
+
+      return {
+        invokeFunction: <I, O>(
+          functionDef: FunctionDefinition<I, O>,
+          input: I,
+        ): Effect.Effect<O, never, InvocationServices> =>
+          Effect.gen(function* () {
+            if (functionDef.meta?.deployedFunctionId) {
+              return yield* remoteExecutioner.callFunction<I, O>(functionDef.meta.deployedFunctionId, input);
+            }
+
+            return yield* localExecutioner.invokeFunction(functionDef, input);
+          }),
+      } satisfies Context.Tag.Service<FunctionInvocationService>;
+    }),
+  );
+
+  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
+  static layerTest = ({
+    functions = [],
+  }: {
+    functions?: FunctionDefinition<any, any>[];
+  } = {}): Layer.Layer<
+    FunctionInvocationService,
+    never,
+    AiService.AiService | CredentialsService | DatabaseService | QueueService
+  > =>
+    FunctionInvocationService.layer.pipe(
+      Layer.provide(LocalFunctionExecutionService.layerLive),
+      Layer.provide(FunctionImplementationResolver.layerTest({ functions })),
+      Layer.provide(RemoteFunctionExecutionService.layerMock),
+    );
+
+  // TODO(dmaretskyi): This shouldn't default to all services being not available.
+  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
+  /**
+   * @deprecated Use {@link layerTest} instead.
+   */
+  static layerTestMocked = ({
+    functions,
+  }: {
+    functions: FunctionDefinition<any, any>[];
+  }): Layer.Layer<FunctionInvocationService> =>
+    FunctionInvocationService.layerTest({ functions }).pipe(
+      Layer.provide(AiService.notAvailable),
+      Layer.provide(CredentialsService.configuredLayer([])),
+      Layer.provide(DatabaseService.notAvailable),
+      Layer.provide(QueueService.notAvailable),
+    );
+}

package/src/services/index.ts

@@ -2,11 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './credentials';
 export * from './database';
+export * from './event-logger';
+export * from './function-invocation-service';
+export * from './local-function-execution';
 export * from './queues';
 export * from './service-container';
-export * from './credentials';
 export * from './tracing';
-export * from './event-logger';
 export * from './remote-function-execution-service';
-export * from './local-function-execution';