@dxos/functions 0.8.4-main.fffef41 → 0.9.0

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.fffef41",
+  "version": "0.9.0",
   "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
   "sideEffects": false,
   "type": "module",
@@ -12,8 +16,7 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -23,20 +26,24 @@
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.92.1",
-    "effect": "3.18.3",
-    "@dxos/ai": "0.8.4-main.fffef41",
-    "@dxos/errors": "0.8.4-main.fffef41",
-    "@dxos/echo-db": "0.8.4-main.fffef41",
-    "@dxos/invariant": "0.8.4-main.fffef41",
-    "@dxos/keys": "0.8.4-main.fffef41",
-    "@dxos/log": "0.8.4-main.fffef41",
-    "@dxos/node-std": "0.8.4-main.fffef41",
-    "@dxos/effect": "0.8.4-main.fffef41",
-    "@dxos/schema": "0.8.4-main.fffef41",
-    "@dxos/protocols": "0.8.4-main.fffef41",
-    "@dxos/echo": "0.8.4-main.fffef41",
-    "@dxos/types": "0.8.4-main.fffef41"
+    "@effect-atom/atom": "^0.5.3",
+    "@effect/ai-anthropic": "0.26.0",
+    "@effect/platform": "0.96.1",
+    "effect": "3.21.3",
+    "@dxos/ai": "0.9.0",
+    "@dxos/compute": "0.9.0",
+    "@dxos/echo": "0.9.0",
+    "@dxos/context": "0.9.0",
+    "@dxos/echo-client": "0.9.0",
+    "@dxos/invariant": "0.9.0",
+    "@dxos/errors": "0.9.0",
+    "@dxos/effect": "0.9.0",
+    "@dxos/keys": "0.9.0",
+    "@dxos/log": "0.9.0",
+    "@dxos/protocols": "0.9.0",
+    "@dxos/schema": "0.9.0",
+    "@dxos/node-std": "0.9.0",
+    "@dxos/types": "0.9.0"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -2,8 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './errors';
-export * from './example';
 export * from './sdk';
 export * from './services';
 export * from './types';

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

@@ -0,0 +1,105 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import * as Cause from 'effect/Cause';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import { describe, test } from 'vitest';
+
+import { FunctionsAiMemoizationMissError, FunctionsAiUpstreamError } from '@dxos/compute';
+import { EffectEx } from '@dxos/effect';
+import { type EdgeFunctionEnv } from '@dxos/protocols';
+
+import { FunctionsAiHttpClient } from './functions-ai-http-client';
+
+const makeStubService = (response: Response): EdgeFunctionEnv.FunctionsAiService => ({
+  fetch: async () => response as any,
+});
+
+const runRequest = (service: EdgeFunctionEnv.FunctionsAiService) =>
+  HttpClient.HttpClient.pipe(
+    Effect.flatMap((client) =>
+      client.execute(HttpClientRequest.post('http://internal/provider/anthropic/v1/messages')),
+    ),
+    Effect.provide(FunctionsAiHttpClient.layer(service)),
+  );
+
+const extractDefect = (exit: Exit.Exit<unknown, unknown>): Error | null => {
+  if (Exit.isSuccess(exit)) {
+    return null;
+  }
+  return (Chunk.toReadonlyArray(Cause.defects(exit.cause))[0] as Error | undefined) ?? null;
+};
+
+describe('FunctionsAiHttpClient', () => {
+  test('emits FunctionsAiMemoizationMissError when upstream returns the memoization_miss envelope', async ({
+    expect,
+  }) => {
+    const service = makeStubService(
+      new Response(
+        JSON.stringify({
+          type: 'error',
+          error: {
+            type: 'memoization_miss',
+            message: 'No memoized Anthropic conversation found for POST /v1/messages (key=abc).',
+            cacheKey: 'abc',
+          },
+        }),
+        { status: 500, headers: { 'content-type': 'application/json' } },
+      ),
+    );
+
+    const exit = await Effect.runPromiseExit(runRequest(service));
+    const error = extractDefect(exit);
+    expect(error).toBeInstanceOf(FunctionsAiMemoizationMissError);
+    expect(error?.name).toBe('FunctionsAiMemoizationMissError');
+    expect((error as any)?.context?.cacheKey).toBe('abc');
+    expect((error as any)?.context?.status).toBe(500);
+  });
+
+  test('emits FunctionsAiUpstreamError for generic JSON error envelopes', async ({ expect }) => {
+    const service = makeStubService(
+      new Response(
+        JSON.stringify({
+          type: 'error',
+          error: { type: 'overloaded_error', message: 'Server overloaded.' },
+        }),
+        { status: 529, headers: { 'content-type': 'application/json' } },
+      ),
+    );
+
+    const exit = await Effect.runPromiseExit(runRequest(service));
+    const error = extractDefect(exit);
+    expect(error).toBeInstanceOf(FunctionsAiUpstreamError);
+    expect((error as any)?.context?.type).toBe('overloaded_error');
+    expect((error as any)?.context?.status).toBe(529);
+  });
+
+  test('passes non-error responses through unchanged', async ({ expect }) => {
+    const service = makeStubService(
+      new Response(JSON.stringify({ ok: true }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      }),
+    );
+
+    const result = await EffectEx.runAndForwardErrors(runRequest(service));
+    expect(result.status).toBe(200);
+  });
+
+  test('passes non-JSON 5xx responses through to the @effect/ai layer unchanged', async ({ expect }) => {
+    const service = makeStubService(
+      new Response('Internal Server Error', {
+        status: 500,
+        headers: { 'content-type': 'text/plain' },
+      }),
+    );
+
+    const result = await EffectEx.runAndForwardErrors(runRequest(service));
+    expect(result.status).toBe(500);
+  });
+});

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

@@ -0,0 +1,141 @@
+//
+// 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 { FunctionsAiMemoizationMissError, FunctionsAiUpstreamError } from '@dxos/compute';
+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';
+
+/**
+ * Shape of the JSON error envelope emitted by the upstream AI gateway (and by the memoization
+ * layer that fronts it in test environments).
+ *
+ * @example
+ * ```json
+ * {
+ *   "type": "error",
+ *   "error": {
+ *     "type": "memoization_miss",
+ *     "message": "No memoized Anthropic conversation found for ...",
+ *     "cacheKey": "114dae3db8fe60..."
+ *   }
+ * }
+ * ```
+ */
+type UpstreamErrorEnvelope = {
+  type?: string;
+  error?: {
+    type?: string;
+    message?: string;
+    cacheKey?: string;
+  };
+};
+
+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.flatMap((response) =>
+            // Inspect the body before handing the response to `@effect/ai` so that structured
+            // upstream errors surface as typed defects (`FunctionsAiUpstreamError` and friends)
+            // rather than as the generic `HttpResponseError` from `@effect/ai/AiError`.
+            Effect.flatMap(
+              Effect.promise(() => parseUpstreamError(response)),
+              (typedError) =>
+                typedError ? Effect.die(typedError) : Effect.succeed(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));
+}
+
+/**
+ * Returns a typed error if the response is a non-2xx JSON payload matching
+ * {@link UpstreamErrorEnvelope}; otherwise returns `undefined` and the response is forwarded
+ * unchanged.
+ */
+const parseUpstreamError = async (response: Response): Promise<Error | undefined> => {
+  if (response.ok) {
+    return undefined;
+  }
+  const contentType = response.headers.get('content-type') ?? '';
+  if (!contentType.toLowerCase().includes('application/json')) {
+    return undefined;
+  }
+  let body: UpstreamErrorEnvelope;
+  try {
+    body = (await response.clone().json()) as UpstreamErrorEnvelope;
+  } catch {
+    return undefined;
+  }
+  if (!body || body.type !== 'error' || typeof body.error !== 'object' || body.error === null) {
+    return undefined;
+  }
+  const inner = body.error;
+  const message = inner.message ?? `Upstream AI service responded with HTTP ${response.status}`;
+  if (inner.type === 'memoization_miss' && typeof inner.cacheKey === 'string') {
+    return new FunctionsAiMemoizationMissError({
+      message,
+      context: { cacheKey: inner.cacheKey, status: response.status },
+    });
+  }
+  return new FunctionsAiUpstreamError({
+    message,
+    context: { type: inner.type, status: response.status, ...(inner.cacheKey ? { cacheKey: inner.cacheKey } : {}) },
+  });
+};

package/src/protocol/protocol.test.ts

@@ -4,17 +4,17 @@
 
 import { describe, test } from 'vitest';
 
-import { FunctionError } from '../errors';
-import fibFunc from '../example/fib';
-import replyFunc from '../example/reply';
+import { InvalidOperationInputError } from '@dxos/compute';
+import { FibonacciHandler, ReplyHandler } from '@dxos/compute/testing';
+import { DXN } from '@dxos/keys';
 
 import { wrapFunctionHandler } from './protocol';
 
 describe('wrapFunctionHandler', () => {
   test('wraps reply function and executes handler', async ({ expect }) => {
-    const wrapped = wrapFunctionHandler(replyFunc);
+    const wrapped = wrapFunctionHandler(ReplyHandler);
 
-    expect(wrapped.meta.key).toBe('example.org/function/reply');
+    expect(wrapped.meta.key).toBe(DXN.make('org.example.function.reply'));
     expect(wrapped.meta.name).toBe('Reply');
 
     const testData = { message: 'hello' };
@@ -29,9 +29,9 @@ describe('wrapFunctionHandler', () => {
   });
 
   test('wraps fibonacci function with valid input', async ({ expect }) => {
-    const wrapped = wrapFunctionHandler(fibFunc);
+    const wrapped = wrapFunctionHandler(FibonacciHandler);
 
-    expect(wrapped.meta.key).toBe('example.org/function/fib');
+    expect(wrapped.meta.key).toBe(DXN.make('org.example.function.fib'));
     expect(wrapped.meta.name).toBe('Fibonacci');
 
     const result = await wrapped.handler({
@@ -44,8 +44,8 @@ describe('wrapFunctionHandler', () => {
     expect(result).toEqual({ result: '55' });
   });
 
-  test('throws FunctionError on invalid input schema for fibonacci', async ({ expect }) => {
-    const wrapped = wrapFunctionHandler(fibFunc);
+  test('throws InvalidOperationInputError on invalid input schema for fibonacci', async ({ expect }) => {
+    const wrapped = wrapFunctionHandler(FibonacciHandler);
 
     await expect(
       wrapped.handler({
@@ -54,6 +54,6 @@ describe('wrapFunctionHandler', () => {
           services: {},
         },
       }),
-    ).rejects.toThrow(FunctionError);
+    ).rejects.toThrow(InvalidOperationInputError);
   });
 });