@dxos/functions 0.8.4-main.7ace549 → 0.8.4-main.937b3ca

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.7ace549",
+  "version": "0.8.4-main.937b3ca",
   "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,
@@ -23,21 +27,23 @@
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.92.1",
-    "effect": "3.18.3",
-    "@dxos/ai": "0.8.4-main.7ace549",
-    "@dxos/context": "0.8.4-main.7ace549",
-    "@dxos/effect": "0.8.4-main.7ace549",
-    "@dxos/errors": "0.8.4-main.7ace549",
-    "@dxos/echo": "0.8.4-main.7ace549",
-    "@dxos/invariant": "0.8.4-main.7ace549",
-    "@dxos/echo-db": "0.8.4-main.7ace549",
-    "@dxos/log": "0.8.4-main.7ace549",
-    "@dxos/node-std": "0.8.4-main.7ace549",
-    "@dxos/protocols": "0.8.4-main.7ace549",
-    "@dxos/schema": "0.8.4-main.7ace549",
-    "@dxos/types": "0.8.4-main.7ace549",
-    "@dxos/keys": "0.8.4-main.7ace549"
+    "@effect/ai-anthropic": "0.22.0",
+    "@effect/platform": "0.93.6",
+    "effect": "3.19.11",
+    "@dxos/ai": "0.8.4-main.937b3ca",
+    "@dxos/echo-db": "0.8.4-main.937b3ca",
+    "@dxos/context": "0.8.4-main.937b3ca",
+    "@dxos/echo": "0.8.4-main.937b3ca",
+    "@dxos/effect": "0.8.4-main.937b3ca",
+    "@dxos/errors": "0.8.4-main.937b3ca",
+    "@dxos/invariant": "0.8.4-main.937b3ca",
+    "@dxos/keys": "0.8.4-main.937b3ca",
+    "@dxos/log": "0.8.4-main.937b3ca",
+    "@dxos/node-std": "0.8.4-main.937b3ca",
+    "@dxos/protocols": "0.8.4-main.937b3ca",
+    "@dxos/schema": "0.8.4-main.937b3ca",
+    "@dxos/operation": "0.8.4-main.937b3ca",
+    "@dxos/types": "0.8.4-main.937b3ca"
   },
   "publishConfig": {
     "access": "public"

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 });
   }
 }
 
-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/operation-compatibility.test.ts

@@ -0,0 +1,185 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import { describe, expect, test } from 'vitest';
+
+import { FunctionDefinition, defineFunction } from './sdk';
+
+describe('Function/Operation Compatibility', () => {
+  test('can convert FunctionDefinition to OperationDefinition', () => {
+    const func = defineFunction({
+      key: 'test.function',
+      name: 'Test Function',
+      description: 'A test function',
+      inputSchema: Schema.Struct({ value: Schema.Number }),
+      outputSchema: Schema.Struct({ result: Schema.String }),
+      handler: async ({ data }) => {
+        return { result: data.value.toString() };
+      },
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    expect(op.meta.key).toBe('test.function');
+    expect(op.meta.name).toBe('Test Function');
+    expect(op.meta.description).toBe('A test function');
+    expect(Schema.isSchema(op.schema.input)).toBe(true);
+    expect(Schema.isSchema(op.schema.output)).toBe(true);
+  });
+
+  test('converted operation has matching schemas', () => {
+    const inputSchema = Schema.Struct({
+      name: Schema.String,
+      age: Schema.Number,
+    });
+    const outputSchema = Schema.Struct({
+      greeting: Schema.String,
+    });
+
+    const func = defineFunction({
+      key: 'test.greet',
+      name: 'Greet',
+      inputSchema,
+      outputSchema,
+      handler: async ({ data }) => {
+        return { greeting: `Hello, ${data.name}!` };
+      },
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    // Verify schemas match
+    const testInput = { name: 'Alice', age: 30 };
+    const validatedInput = Schema.decodeSync(op.schema.input)(testInput);
+    expect(validatedInput).toEqual(testInput);
+
+    const testOutput = { greeting: 'Hello, Alice!' };
+    const validatedOutput = Schema.decodeSync(op.schema.output)(testOutput);
+    expect(validatedOutput).toEqual(testOutput);
+  });
+
+  test('converted operation preserves metadata', () => {
+    const func = defineFunction({
+      key: 'test.meta',
+      name: 'Meta Test',
+      description: 'Tests metadata preservation',
+      inputSchema: Schema.Void,
+      outputSchema: Schema.Void,
+      handler: async () => {},
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    expect(op.meta.key).toBe('test.meta');
+    expect(op.meta.name).toBe('Meta Test');
+    expect(op.meta.description).toBe('Tests metadata preservation');
+  });
+
+  test('converted operation is pipeable', () => {
+    const func = defineFunction({
+      key: 'test.pipe',
+      name: 'Pipe Test',
+      inputSchema: Schema.Void,
+      outputSchema: Schema.Void,
+      handler: async () => {},
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    expect(typeof op.pipe).toBe('function');
+  });
+
+  test('handles functions without output schema', () => {
+    const func = defineFunction({
+      key: 'test.no-output',
+      name: 'No Output',
+      inputSchema: Schema.Struct({ value: Schema.Number }),
+      handler: async ({ data }) => {
+        return data.value * 2;
+      },
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    expect(op.meta.key).toBe('test.no-output');
+    expect(Schema.isSchema(op.schema.output)).toBe(true);
+  });
+
+  test('converted operation includes handler', () => {
+    const func = defineFunction({
+      key: 'test.handler',
+      name: 'Handler Test',
+      inputSchema: Schema.Struct({ value: Schema.Number }),
+      outputSchema: Schema.Struct({ doubled: Schema.Number }),
+      handler: async ({ data }) => {
+        return { doubled: data.value * 2 };
+      },
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    expect(op.handler).toBeDefined();
+    expect(typeof op.handler).toBe('function');
+  });
+
+  test('converted operation has handler function', () => {
+    const func = defineFunction({
+      key: 'test.execute',
+      name: 'Execute Test',
+      inputSchema: Schema.Struct({ value: Schema.Number }),
+      outputSchema: Schema.Struct({ result: Schema.Number }),
+      handler: async ({ data }) => {
+        return { result: data.value * 3 };
+      },
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    // Handler is present and is a function that returns an Effect
+    expect(op.handler).toBeDefined();
+    const effect = op.handler({ value: 5 });
+    // Verify it returns an Effect-like object
+    expect(effect).toHaveProperty('pipe');
+  });
+
+  test('converted operation works with Effect-based handlers', () => {
+    const func = defineFunction({
+      key: 'test.effect',
+      name: 'Effect Test',
+      inputSchema: Schema.Struct({ value: Schema.Number }),
+      outputSchema: Schema.Struct({ result: Schema.Number }),
+      handler: Effect.fn(function* ({ data }) {
+        return { result: data.value * 4 };
+      }),
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    // Handler is present and produces an Effect
+    expect(op.handler).toBeDefined();
+    const effect = op.handler({ value: 3 });
+    expect(effect).toHaveProperty('pipe');
+  });
+
+  test('converted operation works with synchronous handlers', () => {
+    const func = defineFunction({
+      key: 'test.sync',
+      name: 'Sync Test',
+      inputSchema: Schema.Struct({ value: Schema.Number }),
+      outputSchema: Schema.Struct({ result: Schema.Number }),
+      handler: ({ data }) => {
+        return { result: data.value * 5 };
+      },
+    });
+
+    const op = FunctionDefinition.toOperation(func);
+
+    // Handler is present and produces an Effect
+    expect(op.handler).toBeDefined();
+    const effect = op.handler({ value: 2 });
+    expect(effect).toHaveProperty('pipe');
+  });
+});

package/src/protocol/functions-ai-http-client.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Headers from '@effect/platform/Headers';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientError from '@effect/platform/HttpClientError';
+import * as HttpClientResponse from '@effect/platform/HttpClientResponse';
+import * as Effect from 'effect/Effect';
+import * as FiberRef from 'effect/FiberRef';
+import * as Layer from 'effect/Layer';
+import * as Stream from 'effect/Stream';
+
+import { log } from '@dxos/log';
+import { type EdgeFunctionEnv, ErrorCodec } from '@dxos/protocols';
+/**
+ * Copy pasted from https://github.com/Effect-TS/effect/blob/main/packages/platform/src/internal/fetchHttpClient.ts
+ */
+export const requestInitTagKey = '@effect/platform/FetchHttpClient/FetchOptions';
+
+export class FunctionsAiHttpClient {
+  static make = (service: EdgeFunctionEnv.FunctionsAiService) =>
+    HttpClient.make((request, url, signal, fiber) => {
+      const context = fiber.getFiberRef(FiberRef.currentContext);
+      const options: RequestInit = context.unsafeMap.get(requestInitTagKey) ?? {};
+      const headers = options.headers
+        ? Headers.merge(Headers.fromInput(options.headers), request.headers)
+        : request.headers;
+
+      const send = (body: BodyInit | undefined) =>
+        Effect.tryPromise({
+          try: () =>
+            service.fetch(
+              new Request(url, {
+                ...options,
+                method: request.method,
+                headers,
+                body,
+                // Note: Don't pass signal - it can't be serialized through RPC
+              }),
+            ),
+          catch: (cause) => {
+            log.error('Failed to fetch', { errorSerialized: ErrorCodec.encode(cause as Error) });
+            return new HttpClientError.RequestError({
+              request,
+              reason: 'Transport',
+              cause,
+            });
+          },
+        }).pipe(Effect.map((response) => HttpClientResponse.fromWeb(request, response)));
+
+      switch (request.body._tag) {
+        case 'Raw':
+        case 'Uint8Array':
+          return send(request.body.body as any);
+        case 'FormData':
+          return send(request.body.formData);
+        case 'Stream':
+          return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect.flatMap(send));
+      }
+
+      return send(undefined);
+    });
+
+  static layer = (service: EdgeFunctionEnv.FunctionsAiService) =>
+    Layer.succeed(HttpClient.HttpClient, FunctionsAiHttpClient.make(service));
+}

package/src/protocol/protocol.ts

@@ -2,23 +2,28 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as AnthropicClient from '@effect/ai-anthropic/AnthropicClient';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { AiService } from '@dxos/ai';
+import { AiModelResolver, AiService } from '@dxos/ai';
+import { AnthropicResolver } from '@dxos/ai/resolvers';
 import { LifecycleState, Resource } from '@dxos/context';
-import { Type } from '@dxos/echo';
+import { Database, Ref, Type } from '@dxos/echo';
+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 { type FunctionProtocol } from '@dxos/protocols';
 
 import { FunctionError } from '../errors';
 import { FunctionDefinition, type FunctionServices } from '../sdk';
-import { CredentialsService, DatabaseService, FunctionInvocationService, TracingService } from '../services';
-import { QueueService } from '../services';
+import { CredentialsService, FunctionInvocationService, QueueService, TracingService } from '../services';
+
+import { FunctionsAiHttpClient } from './functions-ai-http-client';
 
 /**
  * Wraps a function handler made with `defineFunction` to a protocol that the functions-runtime expects.
@@ -39,7 +44,7 @@ export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.
     },
     handler: async ({ data, context }) => {
       if (
-        (func.services.includes(DatabaseService.key) || func.services.includes(QueueService.key)) &&
+        (func.services.includes(Database.Service.key) || func.services.includes(QueueService.key)) &&
         (!context.services.dataService || !context.services.queryService)
       ) {
         throw new FunctionError({
@@ -61,17 +66,22 @@ export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.
 
         if (func.types.length > 0) {
           invariant(funcContext.db, 'Database is required for functions with types');
-          funcContext.db.graph.schemaRegistry.addSchema(func.types);
+          await funcContext.db.graph.schemaRegistry.register(func.types as Type.Entity.Any[]);
         }
 
+        const dataWithDecodedRefs =
+          funcContext.db && !SchemaAST.isAnyKeyword(func.inputSchema.ast)
+            ? decodeRefsFromSchema(func.inputSchema.ast, data, funcContext.db)
+            : data;
+
         let result = await func.handler({
           // TODO(dmaretskyi): Fix the types.
           context: context as any,
-          data,
+          data: dataWithDecodedRefs,
         });
 
         if (Effect.isEffect(result)) {
-          result = await Effect.runPromise(
+          result = await runAndForwardErrors(
             (result as Effect.Effect<unknown, unknown, FunctionServices>).pipe(
               Effect.orDie,
               Effect.provide(funcContext.createLayer()),
@@ -121,6 +131,7 @@ class FunctionContext extends Resource {
             spaceId: this.context.spaceId ?? failedInvariant(),
             spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant('spaceKey missing in context')),
             reactiveSchemaQuery: false,
+            preloadSchemaOnOpen: false,
           })
         : undefined;
 
@@ -138,19 +149,114 @@ class FunctionContext extends Resource {
   createLayer(): Layer.Layer<FunctionServices> {
     assertState(this._lifecycleState === LifecycleState.OPEN, 'FunctionContext is not open');
 
-    const dbLayer = this.db ? DatabaseService.layer(this.db) : DatabaseService.notAvailable;
+    const dbLayer = this.db ? Database.Service.layer(this.db) : Database.Service.notAvailable;
     const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
     const credentials = dbLayer
-      ? CredentialsService.layerFromDatabase().pipe(Layer.provide(dbLayer))
+      ? CredentialsService.layerFromDatabase({ caching: true }).pipe(Layer.provide(dbLayer))
       : CredentialsService.configuredLayer([]);
     const functionInvocationService = MockedFunctionInvocationService;
-    const aiService = AiService.notAvailable;
     const tracing = TracingService.layerNoop;
 
-    return Layer.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiService, tracing);
+    const aiLayer = this.context.services.functionsAiService
+      ? AiModelResolver.AiModelResolver.buildAiService.pipe(
+          Layer.provide(
+            AnthropicResolver.make().pipe(
+              Layer.provide(
+                AnthropicClient.layer({
+                  // Note: It doesn't matter what is base url here, it will be proxied to ai gateway in edge.
+                  apiUrl: 'http://internal/provider/anthropic',
+                }).pipe(Layer.provide(FunctionsAiHttpClient.layer(this.context.services.functionsAiService))),
+              ),
+            ),
+          ),
+        )
+      : AiService.notAvailable;
+
+    return Layer.mergeAll(
+      dbLayer, //
+      queuesLayer,
+      credentials,
+      functionInvocationService,
+      aiLayer,
+      tracing,
+    );
   }
 }
 
 const MockedFunctionInvocationService = Layer.succeed(FunctionInvocationService, {
   invokeFunction: () => Effect.die('Calling functions from functions is not implemented yet.'),
+  resolveFunction: () => Effect.die('Not implemented.'),
 });
+
+const decodeRefsFromSchema = (ast: SchemaAST.AST, value: unknown, db: EchoDatabaseImpl): unknown => {
+  if (value == null) {
+    return value;
+  }
+
+  const encoded = SchemaAST.encodedBoundAST(ast);
+  if (Ref.isRefType(encoded)) {
+    if (Ref.isRef(value)) {
+      return value;
+    }
+
+    if (typeof value === 'object' && value !== null && typeof (value as any)['/'] === 'string') {
+      const resolver = db.graph.createRefResolver({ context: { space: db.spaceId } });
+      return refFromEncodedReference(value as any, resolver);
+    }
+
+    return value;
+  }
+
+  switch (encoded._tag) {
+    case 'TypeLiteral': {
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return value;
+      }
+      const result: Record<string, unknown> = { ...(value as any) };
+      for (const prop of SchemaAST.getPropertySignatures(encoded)) {
+        const key = prop.name.toString();
+        if (key in result) {
+          result[key] = decodeRefsFromSchema(prop.type, (result as any)[key], db);
+        }
+      }
+      return result;
+    }
+
+    case 'TupleType': {
+      if (!Array.isArray(value)) {
+        return value;
+      }
+
+      // For arrays, effect uses TupleType with empty elements and a single rest element.
+      if (encoded.elements.length === 0 && encoded.rest.length === 1) {
+        const elementType = encoded.rest[0].type;
+        return (value as unknown[]).map((item) => decodeRefsFromSchema(elementType, item, db));
+      }
+
+      return value;
+    }
+
+    case 'Union': {
+      // Optional values are represented as union with undefined.
+      const nonUndefined = encoded.types.filter((t) => !SchemaAST.isUndefinedKeyword(t));
+      if (nonUndefined.length === 1) {
+        return decodeRefsFromSchema(nonUndefined[0], value, db);
+      }
+
+      // For other unions we can't safely pick a branch without validating.
+      return value;
+    }
+
+    case 'Suspend': {
+      return decodeRefsFromSchema(encoded.f(), value, db);
+    }
+
+    case 'Refinement': {
+      return decodeRefsFromSchema(encoded.from, value, db);
+    }
+
+    default: {
+      return value;
+    }
+  }
+};

package/src/sdk.ts

@@ -8,8 +8,9 @@ import * as Schema from 'effect/Schema';
 
 import { type AiService } from '@dxos/ai';
 import { Obj, Type } from '@dxos/echo';
-import { type DatabaseService } from '@dxos/echo-db';
+import { type Database } from '@dxos/echo';
 import { assertArgument, failedInvariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
 
 import {
   type CredentialsService,
@@ -37,7 +38,7 @@ export type FunctionServices =
   | InvocationServices
   | AiService.AiService
   | CredentialsService
-  | DatabaseService
+  | Database.Service
   | QueueService
   | FunctionInvocationService;
 
@@ -79,7 +80,7 @@ export type FunctionDefinition<T = any, O = any, S extends FunctionServices = Fu
    * List of types the function uses.
    * This is used to ensure that the types are available when the function is executed.
    */
-  types: readonly Type.Obj.Any[];
+  types: readonly Type.Entity.Any[];
 
   /**
    * Keys of the required services.
@@ -119,7 +120,7 @@ export type FunctionProps<T, O> = {
    * List of types the function uses.
    * This is used to ensure that the types are available when the function is executed.
    */
-  types?: readonly Type.Obj.Any[];
+  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>[];
 
@@ -184,11 +185,58 @@ const getServiceKeys = (services: readonly Context.Tag<any, any>[]) => {
     if (typeof tag.key === 'string') {
       return tag.key;
     }
-    console.log(tag);
     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 => {
@@ -202,6 +250,7 @@ export const FunctionDefinition = {
     assertArgument(Obj.instanceOf(Function.Function, functionObj), 'functionObj');
     return deserializeFunction(functionObj);
   },
+  toOperation,
 };
 
 export const serializeFunction = (functionDef: FunctionDefinition.Any): Function.Function => {
@@ -215,7 +264,7 @@ export const serializeFunction = (functionDef: FunctionDefinition.Any): Function
     services: functionDef.services,
   });
   if (functionDef.meta?.deployedFunctionId) {
-    setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta.deployedFunctionId);
+    Obj.change(fn, (fn) => setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta!.deployedFunctionId!));
   }
   return fn;
 };