@dxos/functions 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.9be5663bfe",
+  "version": "0.8.4-main.abd8ff62ef",
   "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -17,11 +17,6 @@
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
       "default": "./dist/lib/neutral/index.mjs"
-    },
-    "./Trace": {
-      "source": "./src/Trace.ts",
-      "types": "./dist/types/src/Trace.d.ts",
-      "default": "./dist/lib/neutral/Trace.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -35,20 +30,20 @@
     "@effect/ai-anthropic": "0.23.0",
     "@effect/platform": "0.94.4",
     "effect": "3.20.0",
-    "@dxos/ai": "0.8.4-main.9be5663bfe",
-    "@dxos/echo": "0.8.4-main.9be5663bfe",
-    "@dxos/context": "0.8.4-main.9be5663bfe",
-    "@dxos/echo-db": "0.8.4-main.9be5663bfe",
-    "@dxos/errors": "0.8.4-main.9be5663bfe",
-    "@dxos/keys": "0.8.4-main.9be5663bfe",
-    "@dxos/log": "0.8.4-main.9be5663bfe",
-    "@dxos/operation": "0.8.4-main.9be5663bfe",
-    "@dxos/protocols": "0.8.4-main.9be5663bfe",
-    "@dxos/node-std": "0.8.4-main.9be5663bfe",
-    "@dxos/schema": "0.8.4-main.9be5663bfe",
-    "@dxos/effect": "0.8.4-main.9be5663bfe",
-    "@dxos/types": "0.8.4-main.9be5663bfe",
-    "@dxos/invariant": "0.8.4-main.9be5663bfe"
+    "@dxos/ai": "0.8.4-main.abd8ff62ef",
+    "@dxos/context": "0.8.4-main.abd8ff62ef",
+    "@dxos/compute": "0.8.4-main.abd8ff62ef",
+    "@dxos/echo": "0.8.4-main.abd8ff62ef",
+    "@dxos/effect": "0.8.4-main.abd8ff62ef",
+    "@dxos/echo-db": "0.8.4-main.abd8ff62ef",
+    "@dxos/errors": "0.8.4-main.abd8ff62ef",
+    "@dxos/invariant": "0.8.4-main.abd8ff62ef",
+    "@dxos/keys": "0.8.4-main.abd8ff62ef",
+    "@dxos/log": "0.8.4-main.abd8ff62ef",
+    "@dxos/node-std": "0.8.4-main.abd8ff62ef",
+    "@dxos/protocols": "0.8.4-main.abd8ff62ef",
+    "@dxos/schema": "0.8.4-main.abd8ff62ef",
+    "@dxos/types": "0.8.4-main.abd8ff62ef"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -2,13 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './errors';
-export * from './example';
-export * as Process from './process/Process';
-export * as ServiceResolver from './process/ServiceResolver';
-export * from './process/StorageService';
 export * from './sdk';
 export * from './services';
 export * from './types';
 export * from './protocol';
-export * as Trace from './Trace';

package/src/protocol/protocol.test.ts

@@ -4,16 +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' };
@@ -28,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({
@@ -43,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({
@@ -53,6 +53,6 @@ describe('wrapFunctionHandler', () => {
           services: {},
         },
       }),
-    ).rejects.toThrow(FunctionError);
+    ).rejects.toThrow(InvalidOperationInputError);
   });
 });

package/src/protocol/protocol.ts

@@ -10,6 +10,13 @@ import * as SchemaAST from 'effect/SchemaAST';
 
 import { AiModelResolver, AiService } from '@dxos/ai';
 import { AnthropicResolver } from '@dxos/ai/resolvers';
+import {
+  FunctionError,
+  InvalidOperationInputError,
+  InvalidOperationOutputError,
+  Operation,
+  Trace,
+} from '@dxos/compute';
 import { LifecycleState, Resource } from '@dxos/context';
 import { Database, Feed, JsonSchema, Ref, type Type } from '@dxos/echo';
 import { EchoClient, type EchoDatabaseImpl, type QueueFactory, createFeedServiceLayer } from '@dxos/echo-db';
@@ -17,13 +24,15 @@ import { refFromEncodedReference } from '@dxos/echo/internal';
 import { runAndForwardErrors } from '@dxos/effect';
 import { assertState, failedInvariant, invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
-import { Operation } from '@dxos/operation';
 import { type FunctionProtocol } from '@dxos/protocols';
 
-import { FunctionError } from '../errors';
 import { type FunctionServices } from '../sdk';
-import { CredentialsService, FunctionInvocationService, QueueService, TracingService } from '../services';
-import * as Trace from '../Trace';
+import {
+  configuredCredentialsLayer,
+  credentialsLayerFromDatabase,
+  FunctionInvocationService,
+  QueueService,
+} from '../services';
 import { FunctionsAiHttpClient } from './functions-ai-http-client';
 
 /**
@@ -61,9 +70,12 @@ export const wrapFunctionHandler = (func: Operation.WithHandler<Operation.Defini
       try {
         if (!SchemaAST.isAnyKeyword(func.input.ast)) {
           try {
-            Schema.validateSync(func.input)(data);
-          } catch (error) {
-            throw new FunctionError({ message: 'Invalid input schema', cause: error });
+            Schema.validateSync(func.input, { onExcessProperty: 'error' })(data);
+          } catch (error: any) {
+            throw new InvalidOperationInputError({
+              message: `Operation input did not match schema (${func.meta.key}): ${error.message}`,
+              cause: error,
+            });
           }
         }
 
@@ -91,7 +103,14 @@ export const wrapFunctionHandler = (func: Operation.WithHandler<Operation.Defini
         }
 
         if (func.output && !SchemaAST.isAnyKeyword(func.output.ast)) {
-          Schema.validateSync(func.output)(result);
+          try {
+            Schema.validateSync(func.output, { onExcessProperty: 'error' })(result);
+          } catch (error: any) {
+            throw new InvalidOperationOutputError({
+              message: `Operation output did not match schema (${func.meta.key}): ${error.message}`,
+              cause: error,
+            });
+          }
         }
 
         return result;
@@ -154,10 +173,10 @@ class FunctionContext extends Resource {
     const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
     const feedLayer = this.queues ? createFeedServiceLayer(this.queues) : Feed.notAvailable;
     const credentials = dbLayer
-      ? CredentialsService.layerFromDatabase({ caching: true }).pipe(Layer.provide(dbLayer))
-      : CredentialsService.configuredLayer([]);
+      ? credentialsLayerFromDatabase({ caching: true }).pipe(Layer.provide(dbLayer))
+      : configuredCredentialsLayer([]);
     const functionInvocationService = MockedFunctionInvocationService;
-    const tracing = TracingService.layerNoop;
+    const operationServiceLayer = MockedOperationServiceLayer;
 
     const aiLayer = this.context.services.functionsAiService
       ? AiModelResolver.AiModelResolver.buildAiService.pipe(
@@ -180,8 +199,8 @@ class FunctionContext extends Resource {
       feedLayer,
       credentials,
       functionInvocationService,
+      operationServiceLayer,
       aiLayer,
-      tracing,
       // TODO(dmaretskyi): Forward trace events.
       Trace.writerLayerNoop,
     );
@@ -193,6 +212,12 @@ const MockedFunctionInvocationService = Layer.succeed(FunctionInvocationService,
   resolveFunction: () => Effect.die('Not implemented.'),
 });
 
+const MockedOperationServiceLayer = Layer.succeed(Operation.Service, {
+  invoke: () => Effect.die('Calling operations from functions is not implemented yet.'),
+  schedule: () => Effect.die('Not implemented.'),
+  invokePromise: async () => ({ error: new Error('Not implemented') }),
+} as any);
+
 const decodeRefsFromSchema = (ast: SchemaAST.AST, value: unknown, db: EchoDatabaseImpl): unknown => {
   if (value == null) {
     return value;

package/src/sdk.ts

@@ -3,37 +3,27 @@
 //
 
 import { type AiService } from '@dxos/ai';
+import { type Credential, type Operation, type Trace } from '@dxos/compute';
 import { type Database, type Feed } from '@dxos/echo';
-import { type Trace } from '@dxos/functions';
 
-import {
-  type CredentialsService,
-  type FunctionInvocationService,
-  type QueueService,
-  type TracingService,
-} from './services';
+import { type FunctionInvocationService, type QueueService } from './services';
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
 // https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
 // https://www.npmjs.com/package/aws-lambda
 
-/**
- * Services that are provided at the function call site by the caller.
- */
-export type InvocationServices = TracingService;
-
 /**
  * Services that are available to invoked functions.
  * @deprecated
  */
 export type FunctionServices =
-  | InvocationServices
   | AiService.AiService
-  | CredentialsService
+  | Credential.CredentialsService
   | Database.Service
   // TODO(wittjosiah): Remove QueueService — use Feed.FeedService instead.
   | QueueService
   | Feed.FeedService
   | Trace.TraceService
-  | FunctionInvocationService;
+  | FunctionInvocationService
+  | Operation.Service;

package/src/services/credentials.ts

@@ -10,136 +10,24 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Redacted from 'effect/Redacted';
 
+import { Credential } from '@dxos/compute';
 import { Query } from '@dxos/echo';
 import { Database } from '@dxos/echo';
 import { AccessToken } from '@dxos/types';
 
-export type CredentialQuery = {
-  service?: string;
-};
-
-// TODO(dmaretskyi): Unify with other apis.
-// packages/sdk/schema/src/common/access-token.ts
-export type ServiceCredential = {
-  service: string;
-
-  // TODO(dmaretskyi): Build out.
-  apiKey?: string;
-};
-
-export class CredentialsService extends Context.Tag('@dxos/functions/CredentialsService')<
-  CredentialsService,
-  {
-    /**
-     * Query all.
-     */
-    queryCredentials: (query: CredentialQuery) => Promise<ServiceCredential[]>;
-
-    /**
-     * Get a single credential.
-     * @throws {Error} If no credential is found.
-     */
-    getCredential: (query: CredentialQuery) => Promise<ServiceCredential>;
-  }
->() {
-  static getCredential = (query: CredentialQuery): Effect.Effect<ServiceCredential, never, CredentialsService> =>
-    Effect.gen(function* () {
-      const credentials = yield* CredentialsService;
-      return yield* Effect.promise(() => credentials.getCredential(query));
-    });
-
-  static getApiKey = (query: CredentialQuery): Effect.Effect<Redacted.Redacted<string>, never, CredentialsService> =>
-    Effect.gen(function* () {
-      const credential = yield* CredentialsService.getCredential(query);
-      if (!credential.apiKey) {
-        throw new Error(`API key not found for service: ${query.service}`);
-      }
-      return Redacted.make(credential.apiKey);
-    });
-
-  static configuredLayer = (credentials: ServiceCredential[]) =>
-    Layer.succeed(CredentialsService, new ConfiguredCredentialsService(credentials));
-
-  static layerConfig = (
-    credentials: {
-      service: string;
-      apiKey: Config.Config<Redacted.Redacted<string>>;
-    }[],
-  ) =>
-    Layer.effect(
-      CredentialsService,
-      Effect.gen(function* () {
-        const serviceCredentials = yield* Effect.forEach(credentials, ({ service, apiKey }) =>
-          Effect.gen(function* () {
-            return {
-              service,
-              apiKey: Redacted.value(yield* apiKey),
-            };
-          }),
-        );
-
-        return new ConfiguredCredentialsService(serviceCredentials);
-      }),
-    );
-
-  static layerFromDatabase = ({ caching = false }: { caching?: boolean } = {}) =>
-    Layer.effect(
-      CredentialsService,
-      Effect.gen(function* () {
-        const dbService = yield* Database.Service;
-        const cache = new Map<string, ServiceCredential[]>();
-
-        const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
-          const cacheKey = JSON.stringify(query);
-          if (caching && cache.has(cacheKey)) {
-            return cache.get(cacheKey)!;
-          }
-
-          const accessTokens = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
-          const credentials = accessTokens
-            .filter((accessToken) => accessToken.source === query.service)
-            .map((accessToken) => ({
-              service: accessToken.source,
-              apiKey: accessToken.token,
-            }));
-
-          if (caching) {
-            cache.set(cacheKey, credentials);
-          }
+export class ConfiguredCredentialsService implements Context.Tag.Service<Credential.CredentialsService> {
+  constructor(private readonly credentials: Credential.ServiceCredential[] = []) {}
 
-          return credentials;
-        };
-
-        return {
-          getCredential: async (query) => {
-            const credentials = await queryCredentials(query);
-            if (credentials.length === 0) {
-              throw new Error(`Credential not found for service: ${query.service}`);
-            }
-
-            return credentials[0];
-          },
-          queryCredentials: async (query) => {
-            return queryCredentials(query);
-          },
-        };
-      }),
-    );
-}
-
-export class ConfiguredCredentialsService implements Context.Tag.Service<CredentialsService> {
-  constructor(private readonly credentials: ServiceCredential[] = []) {}
-
-  addCredentials(credentials: ServiceCredential[]): ConfiguredCredentialsService {
+  addCredentials(credentials: Credential.ServiceCredential[]): ConfiguredCredentialsService {
     this.credentials.push(...credentials);
     return this;
   }
 
-  async queryCredentials(query: CredentialQuery): Promise<ServiceCredential[]> {
+  async queryCredentials(query: Credential.CredentialQuery): Promise<Credential.ServiceCredential[]> {
     return this.credentials.filter((credential) => credential.service === query.service);
   }
 
-  async getCredential(query: CredentialQuery): Promise<ServiceCredential> {
+  async getCredential(query: Credential.CredentialQuery): Promise<Credential.ServiceCredential> {
     const credential = this.credentials.find((credential) => credential.service === query.service);
     if (!credential) {
       throw new Error(`Credential not found for service: ${query.service}`);
@@ -157,3 +45,72 @@ export const withAuthorization = (token: string, kind?: 'Bearer' | 'Basic') =>
     const authorization = kind ? `${kind} ${token}` : token;
     return HttpClientRequest.setHeader(request, 'Authorization', authorization);
   });
+
+export const configuredCredentialsLayer = (credentials: Credential.ServiceCredential[]) =>
+  Layer.succeed(Credential.CredentialsService, new ConfiguredCredentialsService(credentials));
+
+export const credentialsLayerConfig = (
+  credentials: {
+    service: string;
+    apiKey: Config.Config<Redacted.Redacted<string>>;
+  }[],
+) =>
+  Layer.effect(
+    Credential.CredentialsService,
+    Effect.gen(function* () {
+      const serviceCredentials = yield* Effect.forEach(credentials, ({ service, apiKey }) =>
+        Effect.gen(function* () {
+          return {
+            service,
+            apiKey: Redacted.value(yield* apiKey),
+          };
+        }),
+      );
+
+      return new ConfiguredCredentialsService(serviceCredentials);
+    }),
+  );
+
+export const credentialsLayerFromDatabase = ({ caching = false }: { caching?: boolean } = {}) =>
+  Layer.effect(
+    Credential.CredentialsService,
+    Effect.gen(function* () {
+      const dbService = yield* Database.Service;
+      const cache = new Map<string, Credential.ServiceCredential[]>();
+
+      const queryCredentials = async (query: Credential.CredentialQuery): Promise<Credential.ServiceCredential[]> => {
+        const cacheKey = JSON.stringify(query);
+        if (caching && cache.has(cacheKey)) {
+          return cache.get(cacheKey)!;
+        }
+
+        const accessTokens = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
+        const credentials = accessTokens
+          .filter((accessToken) => accessToken.source === query.service)
+          .map((accessToken) => ({
+            service: accessToken.source,
+            apiKey: accessToken.token,
+          }));
+
+        if (caching) {
+          cache.set(cacheKey, credentials);
+        }
+
+        return credentials;
+      };
+
+      return {
+        getCredential: async (query) => {
+          const credentials = await queryCredentials(query);
+          if (credentials.length === 0) {
+            throw new Error(`Credential not found for service: ${query.service}`);
+          }
+
+          return credentials[0];
+        },
+        queryCredentials: async (query) => {
+          return queryCredentials(query);
+        },
+      };
+    }),
+  );

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

@@ -5,18 +5,12 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { Operation } from '@dxos/operation';
-
-import type { FunctionNotFoundError } from '../errors';
-import { type InvocationServices } from '../sdk';
+import { type FunctionNotFoundError, Operation } from '@dxos/compute';
 
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
   FunctionInvocationService,
   {
-    invokeFunction<I, O>(
-      functionDef: Operation.Definition<I, O, any>,
-      input: I,
-    ): Effect.Effect<O, never, InvocationServices>;
+    invokeFunction<I, O>(functionDef: Operation.Definition<I, O, any>, input: I): Effect.Effect<O>;
 
     resolveFunction(key: string): Effect.Effect<Operation.Definition.Any, FunctionNotFoundError>;
   }
@@ -29,7 +23,7 @@ export class FunctionInvocationService extends Context.Tag('@dxos/functions/Func
   static invokeFunction = <I, O>(
     functionDef: Operation.Definition<I, O, any>,
     input: I,
-  ): Effect.Effect<O, never, FunctionInvocationService | InvocationServices> =>
+  ): Effect.Effect<O, never, FunctionInvocationService> =>
     Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
 
   static resolveFunction = (

package/src/services/index.ts

@@ -3,9 +3,6 @@
 //
 
 export * from './credentials';
-export { ConfiguredCredentialsService, type ServiceCredential } from './credentials';
-export * from './event-logger';
-export { createEventLogger, createDefectLogger } from './event-logger';
 export * from './function-invocation-service';
 export * from './queues';
-export * from './tracing';
+export { MESSAGE_PROPERTY_TOOL_CALL_ID } from './tracing';

package/src/services/queues.ts

@@ -2,90 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-
-import { type Entity } from '@dxos/echo';
-import { createFeedServiceLayer, type Queue, type QueueAPI, type QueueFactory } from '@dxos/echo-db';
-import type { DXN, QueueSubspaceTag } from '@dxos/keys';
-
-/**
- * Gives access to all queues.
- * @deprecated Use Feed.FeedService instead.
- */
-export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
-  QueueService,
-  {
-    /**
-     * API to access the queues.
-     */
-    readonly queues: QueueAPI;
-
-    /**
-     * The queue that is used to store the context of the current research.
-     * @deprecated Use `ContextQueueService` instead.
-     */
-    readonly queue: Queue | undefined;
-  }
->() {
-  static notAvailable = Layer.succeed(QueueService, {
-    queues: {
-      get(_dxn) {
-        throw new Error('Queues not available');
-      },
-      create() {
-        throw new Error('Queues not available');
-      },
-    },
-    queue: undefined,
-  });
-
-  static make = (queues: QueueFactory, queue?: Queue): Context.Tag.Service<QueueService> => {
-    return {
-      queues,
-      queue,
-    };
-  };
-
-  static layer = (queues: QueueFactory, queue?: Queue): Layer.Layer<QueueService> =>
-    Layer.succeed(QueueService, QueueService.make(queues, queue));
-
-  /**
-   * Gets a queue by its DXN.
-   */
-  static getQueue = <T extends Entity.Unknown = Entity.Unknown>(
-    dxn: DXN,
-  ): Effect.Effect<Queue<T>, never, QueueService> => QueueService.pipe(Effect.map(({ queues }) => queues.get<T>(dxn)));
-
-  /**
-   * Creates a new queue.
-   */
-  static createQueue = <T extends Entity.Unknown = Entity.Unknown>(options?: {
-    subspaceTag?: QueueSubspaceTag;
-  }): Effect.Effect<Queue<T>, never, QueueService> =>
-    QueueService.pipe(Effect.map(({ queues }) => queues.create<T>(options)));
-
-  static append = <T extends Entity.Unknown = Entity.Unknown>(queue: Queue<T>, objects: T[]): Effect.Effect<void> =>
-    Effect.promise(() => queue.append(objects));
-}
-
-/**
- * Gives access to a specific queue passed as a context.
- * @deprecated Use Feed.FeedService instead.
- */
-export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQueueService')<
-  ContextQueueService,
-  {
-    readonly queue: Queue;
-  }
->() {
-  static layer = (queue: Queue) => Layer.succeed(ContextQueueService, { queue });
-}
-
-export const feedServiceFromQueueServiceLayer = Layer.unwrapEffect(
-  Effect.gen(function* () {
-    const { queues } = yield* QueueService;
-    return createFeedServiceLayer(queues);
-  }),
-);
+export { ContextQueueService, QueueService, feedServiceFromQueueServiceLayer } from '@dxos/echo-db';