@dxos/functions 0.8.4-main.ef1bc66f44 → 0.8.4-main.f466a3d56e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.ef1bc66f44",
+  "version": "0.8.4-main.f466a3d56e",
   "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
   "sideEffects": false,
   "type": "module",
@@ -26,23 +26,24 @@
     "src"
   ],
   "dependencies": {
+    "@effect-atom/atom": "^0.5.1",
     "@effect/ai-anthropic": "0.23.0",
     "@effect/platform": "0.94.4",
-    "effect": "3.19.16",
-    "@dxos/context": "0.8.4-main.ef1bc66f44",
-    "@dxos/ai": "0.8.4-main.ef1bc66f44",
-    "@dxos/echo-db": "0.8.4-main.ef1bc66f44",
-    "@dxos/effect": "0.8.4-main.ef1bc66f44",
-    "@dxos/echo": "0.8.4-main.ef1bc66f44",
-    "@dxos/invariant": "0.8.4-main.ef1bc66f44",
-    "@dxos/errors": "0.8.4-main.ef1bc66f44",
-    "@dxos/keys": "0.8.4-main.ef1bc66f44",
-    "@dxos/node-std": "0.8.4-main.ef1bc66f44",
-    "@dxos/operation": "0.8.4-main.ef1bc66f44",
-    "@dxos/log": "0.8.4-main.ef1bc66f44",
-    "@dxos/schema": "0.8.4-main.ef1bc66f44",
-    "@dxos/protocols": "0.8.4-main.ef1bc66f44",
-    "@dxos/types": "0.8.4-main.ef1bc66f44"
+    "effect": "3.20.0",
+    "@dxos/compute": "0.8.4-main.f466a3d56e",
+    "@dxos/context": "0.8.4-main.f466a3d56e",
+    "@dxos/echo-db": "0.8.4-main.f466a3d56e",
+    "@dxos/ai": "0.8.4-main.f466a3d56e",
+    "@dxos/echo": "0.8.4-main.f466a3d56e",
+    "@dxos/effect": "0.8.4-main.f466a3d56e",
+    "@dxos/errors": "0.8.4-main.f466a3d56e",
+    "@dxos/keys": "0.8.4-main.f466a3d56e",
+    "@dxos/invariant": "0.8.4-main.f466a3d56e",
+    "@dxos/node-std": "0.8.4-main.f466a3d56e",
+    "@dxos/protocols": "0.8.4-main.f466a3d56e",
+    "@dxos/log": "0.8.4-main.f466a3d56e",
+    "@dxos/schema": "0.8.4-main.f466a3d56e",
+    "@dxos/types": "0.8.4-main.f466a3d56e"
   },
   "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 { runAndForwardErrors } 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 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 runAndForwardErrors(runRequest(service));
+    expect(result.status).toBe(500);
+  });
+});

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

@@ -11,13 +11,40 @@ 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) => {
@@ -47,7 +74,18 @@ export class FunctionsAiHttpClient {
               cause,
             });
           },
-        }).pipe(Effect.map((response) => HttpClientResponse.fromWeb(request, response)));
+        }).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':
@@ -65,3 +103,39 @@ export class FunctionsAiHttpClient {
   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,16 @@
 
 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 { 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('org.example.function.reply');
     expect(wrapped.meta.name).toBe('Reply');
 
     const testData = { message: 'hello' };
@@ -29,9 +28,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('org.example.function.fib');
     expect(wrapped.meta.name).toBe('Fibonacci');
 
     const result = await wrapped.handler({
@@ -44,8 +43,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 +53,6 @@ describe('wrapFunctionHandler', () => {
           services: {},
         },
       }),
-    ).rejects.toThrow(FunctionError);
+    ).rejects.toThrow(InvalidOperationInputError);
   });
 });