@dxos/functions 0.8.4-main.fffef41 → 0.9.0

package/src/sdk.ts

@@ -2,225 +2,28 @@
 // Copyright 2023 DXOS.org
 //
 
-import type * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-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 { assertArgument, failedInvariant } from '@dxos/invariant';
+import { type Credential, type Operation, type Trace } from '@dxos/compute';
+import { type Database, type Feed } from '@dxos/echo';
 
-import {
-  type CredentialsService,
-  type FunctionInvocationService,
-  type QueueService,
-  type TracingService,
-} from './services';
-import { Function } from './types';
-import { getUserFunctionIdInMetadata, setUserFunctionIdInMetadata } from './types';
+import { type FunctionInvocationService } 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
-  | DatabaseService
-  | QueueService
-  | FunctionInvocationService;
-
-/**
- * Function handler.
- */
-export type FunctionHandler<TData = {}, TOutput = any, S extends FunctionServices = FunctionServices> = (params: {
-  /**
-   * Context available to the function.
-   */
-  context: FunctionContext;
-
-  /**
-   * Data passed as the input to the function.
-   * Must match the function's input schema.
-   * This will be the payload from the trigger or other data passed into the function in a workflow.
-   */
-  data: TData;
-}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, S>;
-
-/**
- * Function context.
- */
-export interface FunctionContext {
-  // TODO(dmaretskyi): Consider what we should put into context.
-}
-
-const typeId = Symbol.for('@dxos/functions/FunctionDefinition');
-
-export type FunctionDefinition<T = any, O = any, S extends FunctionServices = FunctionServices> = {
-  [typeId]: true;
-  key: string;
-  name: string;
-  description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, any>;
-
-  /**
-   * Keys of the required services.
-   */
-  services: readonly string[];
-
-  handler: FunctionHandler<T, O, S>;
-  meta?: {
-    /**
-     * Tools that are projected from functions have this annotation.
-     *
-     * deployedFunctionId:
-     * - Backend deployment ID assigned by the EDGE function service (typically a UUID).
-     * - Used for remote invocation via `FunctionInvocationService` → `RemoteFunctionExecutionService`.
-     * - Persisted on the corresponding ECHO `Function.Function` object's metadata under the
-     *   `FUNCTIONS_META_KEY` and retrieved with `getUserFunctionIdInMetadata`.
-     */
-    deployedFunctionId?: string;
-  };
-};
-
-export declare namespace FunctionDefinition {
-  export type Any = FunctionDefinition<any, any, any>;
-  export type Input<T extends Any> = T extends FunctionDefinition<infer I, infer _O, infer _S> ? I : never;
-  export type Output<T extends Any> = T extends FunctionDefinition<infer _I, infer O, infer _S> ? O : never;
-  export type Services<T extends Any> = T extends FunctionDefinition<infer _I, infer _O, infer S> ? S : never;
-}
-
-export type FunctionProps<T, O> = {
-  key: string;
-  name: string;
-  description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, 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>[];
-
-  handler: FunctionHandler<T, O, FunctionServices>;
-};
-
-// TODO(dmaretskyi): Output type doesn't get typechecked.
-export const defineFunction: {
-  <I, O>(params: FunctionProps<I, O>): FunctionDefinition<I, O, FunctionServices>;
-} = ({ key, name, description, inputSchema, outputSchema = Schema.Any, handler, services }) => {
-  if (!Schema.isSchema(inputSchema)) {
-    throw new Error('Input schema must be a valid schema');
-  }
-  if (typeof handler !== 'function') {
-    throw new Error('Handler must be a function');
-  }
-
-  // Captures the function definition location.
-  const limit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 2;
-  const traceError = new Error();
-  Error.stackTraceLimit = limit;
-  let cache: false | string = false;
-  const captureStackTrace = () => {
-    if (cache !== false) {
-      return cache;
-    }
-    if (traceError.stack !== undefined) {
-      const stack = traceError.stack.split('\n');
-      if (stack[2] !== undefined) {
-        cache = stack[2].trim();
-        return cache;
-      }
-    }
-  };
-
-  const handlerWithSpan = (...args: any[]) => {
-    const result = (handler as any)(...args);
-    if (Effect.isEffect(result)) {
-      return Effect.withSpan(result, `${key ?? name}`, {
-        captureStackTrace,
-      });
-    }
-    return result;
-  };
-
-  return {
-    [typeId]: true,
-    key,
-    name,
-    description,
-    inputSchema,
-    outputSchema,
-    handler: handlerWithSpan,
-    services: !services ? [] : getServiceKeys(services),
-  } satisfies FunctionDefinition.Any;
-};
-
-const getServiceKeys = (services: readonly Context.Tag<any, any>[]) => {
-  return services.map((tag: any) => {
-    if (typeof tag.key === 'string') {
-      return tag.key;
-    }
-    console.log(tag);
-    failedInvariant();
-  });
-};
-
-export const FunctionDefinition = {
-  make: defineFunction,
-  isFunction: (value: unknown): value is FunctionDefinition.Any => {
-    return typeof value === 'object' && value !== null && Symbol.for('@dxos/functions/FunctionDefinition') in value;
-  },
-  serialize: (functionDef: FunctionDefinition.Any): Function.Function => {
-    assertArgument(FunctionDefinition.isFunction(functionDef), 'functionDef');
-    return serializeFunction(functionDef);
-  },
-  deserialize: (functionObj: Function.Function): FunctionDefinition.Any => {
-    assertArgument(Obj.instanceOf(Function.Function, functionObj), 'functionObj');
-    return deserializeFunction(functionObj);
-  },
-};
-
-export const serializeFunction = (functionDef: FunctionDefinition.Any): Function.Function => {
-  const fn = Function.make({
-    key: functionDef.key,
-    name: functionDef.name,
-    version: '0.1.0',
-    description: functionDef.description,
-    inputSchema: Type.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? undefined : Type.toJsonSchema(functionDef.outputSchema),
-    services: functionDef.services,
-  });
-  if (functionDef.meta?.deployedFunctionId) {
-    setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta.deployedFunctionId);
-  }
-  return fn;
-};
-
-export const deserializeFunction = (functionObj: Function.Function): FunctionDefinition<unknown, unknown> => {
-  return {
-    [typeId]: true,
-    // TODO(dmaretskyi): Fix key.
-    key: functionObj.key ?? functionObj.name,
-    name: functionObj.name,
-    description: functionObj.description,
-    inputSchema: !functionObj.inputSchema ? Schema.Unknown : Type.toEffectSchema(functionObj.inputSchema),
-    outputSchema: !functionObj.outputSchema ? undefined : Type.toEffectSchema(functionObj.outputSchema),
-    // TODO(dmaretskyi): This should throw error.
-    handler: () => {},
-    services: functionObj.services ?? [],
-    meta: {
-      deployedFunctionId: getUserFunctionIdInMetadata(Obj.getMeta(functionObj)),
-    },
-  };
-};
+  | Credential.CredentialsService
+  | Database.Service
+  | Feed.FeedService
+  | Trace.TraceService
+  // TODO(dmaretskyi): `FunctionInvocationService` is being phased out in favour of `Operation.Service`;
+  // it's kept in the union until `functions-runtime/local-function-execution.ts` migrates.
+  | FunctionInvocationService
+  | Operation.Service;

package/src/services/credentials.ts

@@ -10,117 +10,23 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Redacted from 'effect/Redacted';
 
-import { Query } from '@dxos/echo';
-import { DatabaseService } from '@dxos/echo-db';
+import { Credential } from '@dxos/compute';
+import { Database, Query } 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 = () =>
-    Layer.effect(
-      CredentialsService,
-      Effect.gen(function* () {
-        const dbService = yield* DatabaseService;
-        const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
-          const { objects: accessTokens } = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
-          return accessTokens
-            .filter((accessToken) => accessToken.source === query.service)
-            .map((accessToken) => ({
-              service: accessToken.source,
-              apiKey: accessToken.token,
-            }));
-        };
-        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[] = []) {}
+export class ConfiguredCredentialsService implements Context.Tag.Service<Credential.CredentialsService> {
+  constructor(private readonly credentials: Credential.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}`);
@@ -131,13 +37,79 @@ export class ConfiguredCredentialsService implements Context.Tag.Service<Credent
 }
 
 /**
- * Maps the request to include the API key from the credential.
+ * Maps the request to include the given token in the Authorization header.
  */
-export const withAuthorization = (query: CredentialQuery, kind?: 'Bearer' | 'Basic') =>
-  HttpClient.mapRequestEffect(
-    Effect.fnUntraced(function* (request) {
-      const key = yield* CredentialsService.getApiKey(query).pipe(Effect.map(Redacted.value));
-      const authorization = kind ? `${kind} ${key}` : key;
-      return HttpClientRequest.setHeader(request, 'Authorization', authorization);
+export const withAuthorization = (token: string, kind?: 'Bearer' | 'Basic') =>
+  HttpClient.mapRequest((request) => {
+    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

@@ -3,21 +3,34 @@
 //
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
-import { type FunctionDefinition, type InvocationServices } from '../sdk';
+import { type FunctionNotFoundError, Operation } from '@dxos/compute';
 
+/**
+ * @deprecated
+ */
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
   FunctionInvocationService,
   {
-    invokeFunction<I, O>(
-      functionDef: FunctionDefinition<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>;
   }
 >() {
+  static layerNotAvailable = Layer.succeed(FunctionInvocationService, {
+    invokeFunction: () => Effect.die('FunctionInvocationService is not avaialble.'),
+    resolveFunction: () => Effect.die('FunctionInvocationService is not available.'),
+  });
+
   static invokeFunction = <I, O>(
-    functionDef: FunctionDefinition<I, O, any>,
+    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 = (
+    key: string,
+  ): Effect.Effect<Operation.Definition.Any, FunctionNotFoundError, FunctionInvocationService> =>
+    Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.resolveFunction)(key);
 }

package/src/services/index.ts

@@ -2,12 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export { DatabaseService } from '@dxos/echo-db';
-
 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/tracing.ts

@@ -2,106 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-
-import { AgentStatus } from '@dxos/ai';
-import { Obj } from '@dxos/echo';
-import type { ObjectId } from '@dxos/echo/internal';
-import { Message } from '@dxos/types';
-
-/**
- * Provides a way for compute primitives (functions, workflows, tools)
- * to emit an execution trace as a series of structured ECHO objects.
- */
-export class TracingService extends Context.Tag('@dxos/functions/TracingService')<
-  TracingService,
-  {
-    /**
-     * Gets the parent message ID.
-     */
-    getTraceContext: () => TracingService.TraceContext;
-
-    /**
-     * Write an event to the tracing queue.
-     * @param event - The event to write. Must be an a typed object.
-     */
-    write: (event: Obj.Any) => void;
-  }
->() {
-  static noop: Context.Tag.Service<TracingService> = {
-    getTraceContext: () => ({}),
-    write: () => {},
-  };
-
-  static layerNoop: Layer.Layer<TracingService> = Layer.succeed(TracingService, TracingService.noop);
-  /**
-   * Creates a TracingService layer that emits events to the parent tracing service.
-   */
-  static layerSubframe = (mapContext: (currentContext: TracingService.TraceContext) => TracingService.TraceContext) =>
-    Layer.effect(
-      TracingService,
-      Effect.gen(function* () {
-        const tracing = yield* TracingService;
-        const context = mapContext(tracing.getTraceContext());
-        return {
-          write: (event) => tracing.write(event),
-          getTraceContext: () => context,
-        };
-      }),
-    );
-
-  /**
-   * Emit the current human-readable execution status.
-   */
-  static emitStatus: (
-    data: Omit<Obj.MakeProps<typeof AgentStatus>, 'created'>,
-  ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
-    const tracing = yield* TracingService;
-    tracing.write(
-      Obj.make(AgentStatus, {
-        parentMessage: tracing.getTraceContext().parentMessage,
-        toolCallId: tracing.getTraceContext().toolCallId,
-        created: new Date().toISOString(),
-        ...data,
-      }),
-    );
-  });
-
-  static emitConverationMessage: (
-    data: Obj.MakeProps<typeof Message.Message>,
-  ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
-    const tracing = yield* TracingService;
-    tracing.write(
-      Obj.make(Message.Message, {
-        parentMessage: tracing.getTraceContext().parentMessage,
-        ...data,
-        properties: {
-          [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
-          ...data.properties,
-        },
-      }),
-    );
-  });
-}
-
-export namespace TracingService {
-  export interface TraceContext {
-    /**
-     * If this thread sprung from a tool call, this is the ID of the message containing the tool call.
-     */
-    parentMessage?: ObjectId;
-
-    /**
-     * If the current thread is a byproduct of a tool call, this is the ID of the tool call.
-     */
-    toolCallId?: string;
-
-    debugInfo?: unknown;
-  }
-}
-
 /**
  * Goes into {@link Message['properties']}
  */

package/src/types/index.ts

@@ -2,8 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * as Function from './Function';
-export * as Script from './Script';
-export * as Trigger from './Trigger';
-export * as TriggerEvent from './TriggerEvent';
 export * from './url';

package/src/types/url.ts

@@ -2,24 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ObjectMeta } from '@dxos/echo/internal';
+import { type Obj } from '@dxos/echo';
 
 // TODO: use URL scheme for source?
-export const FUNCTIONS_META_KEY = 'dxos.org/service/function';
+export const FUNCTIONS_META_KEY = 'org.dxos.service.function';
 
-export const FUNCTIONS_PRESET_META_KEY = 'dxos.org/service/function-preset';
+export const FUNCTIONS_PRESET_META_KEY = 'org.dxos.service.function-preset';
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
  */
-export const getUserFunctionIdInMetadata = (meta: ObjectMeta) => {
+export const getUserFunctionIdInMetadata = (meta: Obj.ReadonlyMeta) => {
   return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
 };
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
+ * Must be called inside Obj.update() since it mutates the meta.
  */
-export const setUserFunctionIdInMetadata = (meta: ObjectMeta, functionId: string) => {
+export const setUserFunctionIdInMetadata = (meta: Obj.Meta, functionId: string) => {
   const key = meta.keys.find((key) => key.source === FUNCTIONS_META_KEY);
   if (key) {
     if (key.id !== functionId) {