@dxos/functions 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.ae835ea",
-  "description": "Functions API and runtime.",
+  "version": "0.8.4-main.bc674ce",
+  "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,
@@ -14,71 +18,32 @@
       "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"
-    },
-    "./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"
     }
   },
   "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.ae835ea",
-    "@dxos/async": "0.8.4-main.ae835ea",
-    "@dxos/client": "0.8.4-main.ae835ea",
-    "@dxos/client-protocol": "0.8.4-main.ae835ea",
-    "@dxos/context": "0.8.4-main.ae835ea",
-    "@dxos/crypto": "0.8.4-main.ae835ea",
-    "@dxos/echo-db": "0.8.4-main.ae835ea",
-    "@dxos/debug": "0.8.4-main.ae835ea",
-    "@dxos/echo": "0.8.4-main.ae835ea",
-    "@dxos/echo-pipeline": "0.8.4-main.ae835ea",
-    "@dxos/echo-protocol": "0.8.4-main.ae835ea",
-    "@dxos/edge-client": "0.8.4-main.ae835ea",
-    "@dxos/effect": "0.8.4-main.ae835ea",
-    "@dxos/errors": "0.8.4-main.ae835ea",
-    "@dxos/invariant": "0.8.4-main.ae835ea",
-    "@dxos/kv-store": "0.8.4-main.ae835ea",
-    "@dxos/live-object": "0.8.4-main.ae835ea",
-    "@dxos/log": "0.8.4-main.ae835ea",
-    "@dxos/node-std": "0.8.4-main.ae835ea",
-    "@dxos/schema": "0.8.4-main.ae835ea",
-    "@dxos/protocols": "0.8.4-main.ae835ea",
-    "@dxos/util": "0.8.4-main.ae835ea",
-    "@dxos/keys": "0.8.4-main.ae835ea"
+    "@effect/ai-anthropic": "0.22.0",
+    "@effect/platform": "0.93.6",
+    "effect": "3.19.11",
+    "@dxos/context": "0.8.4-main.bc674ce",
+    "@dxos/ai": "0.8.4-main.bc674ce",
+    "@dxos/echo": "0.8.4-main.bc674ce",
+    "@dxos/echo-db": "0.8.4-main.bc674ce",
+    "@dxos/effect": "0.8.4-main.bc674ce",
+    "@dxos/errors": "0.8.4-main.bc674ce",
+    "@dxos/keys": "0.8.4-main.bc674ce",
+    "@dxos/invariant": "0.8.4-main.bc674ce",
+    "@dxos/log": "0.8.4-main.bc674ce",
+    "@dxos/node-std": "0.8.4-main.bc674ce",
+    "@dxos/operation": "0.8.4-main.bc674ce",
+    "@dxos/protocols": "0.8.4-main.bc674ce",
+    "@dxos/schema": "0.8.4-main.bc674ce",
+    "@dxos/types": "0.8.4-main.bc674ce"
   },
   "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/example/fib.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '../handler';
+import { defineFunction } from '../sdk';
 
 export default defineFunction({
   key: 'example.org/function/fib',

package/src/example/reply.ts

@@ -6,7 +6,7 @@ import * as Console from 'effect/Console';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '../handler';
+import { defineFunction } from '../sdk';
 
 export default defineFunction({
   key: 'example.org/function/reply',

package/src/example/sleep.ts

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { defineFunction } from '../handler';
+import { defineFunction } from '../sdk';
 
 export default defineFunction({
   key: 'example.org/function/sleep',

package/src/index.ts

@@ -4,10 +4,7 @@
 
 export * from './errors';
 export * from './example';
-export * from './executor';
-export * from './handler';
+export * from './sdk';
 export * from './services';
-export * from './trace';
-export * from './triggers';
 export * from './types';
-export * from './url';
+export * from './protocol';

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/{executor → protocol}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './executor';
+export * from './protocol';

package/src/protocol/protocol.test.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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', () => {
+  test('wraps reply function and executes handler', async ({ expect }) => {
+    const wrapped = wrapFunctionHandler(replyFunc);
+
+    expect(wrapped.meta.key).toBe('example.org/function/reply');
+    expect(wrapped.meta.name).toBe('Reply');
+
+    const testData = { message: 'hello' };
+    const result = await wrapped.handler({
+      data: testData,
+      context: {
+        services: {},
+      },
+    });
+
+    expect(result).toEqual(testData);
+  });
+
+  test('wraps fibonacci function with valid input', async ({ expect }) => {
+    const wrapped = wrapFunctionHandler(fibFunc);
+
+    expect(wrapped.meta.key).toBe('example.org/function/fib');
+    expect(wrapped.meta.name).toBe('Fibonacci');
+
+    const result = await wrapped.handler({
+      data: { iterations: 10 },
+      context: {
+        services: {},
+      },
+    });
+
+    expect(result).toEqual({ result: '55' });
+  });
+
+  test('throws FunctionError on invalid input schema for fibonacci', async ({ expect }) => {
+    const wrapped = wrapFunctionHandler(fibFunc);
+
+    await expect(
+      wrapped.handler({
+        data: { iterations: 'invalid' },
+        context: {
+          services: {},
+        },
+      }),
+    ).rejects.toThrow(FunctionError);
+  });
+});