@dxos/functions 0.8.4-main.c4373fc → 0.8.4-main.cb12b3f963

package/src/services/credentials.ts

@@ -10,118 +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 { DataType } from '@dxos/schema';
-
-import { DatabaseService } from './database';
-
-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(DataType.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);
-          },
-        };
-      }),
-    );
-}
+import { Database } from '@dxos/echo';
+import { AccessToken } from '@dxos/types';
 
-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}`);
@@ -132,13 +38,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

@@ -5,80 +5,29 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { AiService } from '@dxos/ai';
-
-import { type FunctionDefinition } from '../handler';
-
-import { CredentialsService } from './credentials';
-import { DatabaseService } from './database';
-import {
-  FunctionImplementationResolver,
-  type InvocationServices,
-  LocalFunctionExecutionService,
-} from './local-function-execution';
-import { QueueService } from './queues';
-import { RemoteFunctionExecutionService } from './remote-function-execution-service';
+import { type FunctionNotFoundError, Operation } from '@dxos/compute';
 
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
   FunctionInvocationService,
   {
-    invokeFunction<I, O>(functionDef: FunctionDefinition<I, O>, 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 invokeFunction = Effect.serviceFunctionEffect(FunctionInvocationService, (_) => _.invokeFunction);
-
-  static layer = Layer.effect(
-    FunctionInvocationService,
-    Effect.gen(function* () {
-      const localExecutioner = yield* LocalFunctionExecutionService;
-      const remoteExecutioner = yield* RemoteFunctionExecutionService;
-
-      return {
-        invokeFunction: <I, O>(
-          functionDef: FunctionDefinition<I, O>,
-          input: I,
-        ): Effect.Effect<O, never, InvocationServices> =>
-          Effect.gen(function* () {
-            if (functionDef.meta?.deployedFunctionId) {
-              return yield* remoteExecutioner.callFunction<I, O>(functionDef.meta.deployedFunctionId, input);
-            }
-
-            return yield* localExecutioner.invokeFunction(functionDef, input);
-          }),
-      } satisfies Context.Tag.Service<FunctionInvocationService>;
-    }),
-  );
-
-  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
-  static layerTest = ({
-    functions = [],
-  }: {
-    functions?: FunctionDefinition<any, any>[];
-  } = {}): Layer.Layer<
-    FunctionInvocationService,
-    never,
-    AiService.AiService | CredentialsService | DatabaseService | QueueService
-  > =>
-    FunctionInvocationService.layer.pipe(
-      Layer.provide(LocalFunctionExecutionService.layerLive),
-      Layer.provide(FunctionImplementationResolver.layerTest({ functions })),
-      Layer.provide(RemoteFunctionExecutionService.layerMock),
-    );
-
-  // TODO(dmaretskyi): This shouldn't default to all services being not available.
-  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
-  /**
-   * @deprecated Use {@link layerTest} instead.
-   */
-  static layerTestMocked = ({
-    functions,
-  }: {
-    functions: FunctionDefinition<any, any>[];
-  }): Layer.Layer<FunctionInvocationService> =>
-    FunctionInvocationService.layerTest({ functions }).pipe(
-      Layer.provide(AiService.notAvailable),
-      Layer.provide(CredentialsService.configuredLayer([])),
-      Layer.provide(DatabaseService.notAvailable),
-      Layer.provide(QueueService.notAvailable),
-    );
+  static layerNotAvailable = Layer.succeed(FunctionInvocationService, {
+    invokeFunction: () => Effect.die('FunctionInvocationService is not avaialble.'),
+    resolveFunction: () => Effect.die('FunctionInvocationService is not available.'),
+  });
+
+  static invokeFunction = <I, O>(
+    functionDef: Operation.Definition<I, O, any>,
+    input: I,
+  ): 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

@@ -3,11 +3,6 @@
 //
 
 export * from './credentials';
-export * from './database';
-export * from './event-logger';
 export * from './function-invocation-service';
-export * from './local-function-execution';
 export * from './queues';
-export * from './service-container';
-export * from './tracing';
-export * from './remote-function-execution-service';
+export { MESSAGE_PROPERTY_TOOL_CALL_ID } from './tracing';

package/src/services/queues.ts

@@ -2,83 +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 { Obj, Relation } from '@dxos/echo';
-import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
-import type { DXN, QueueSubspaceTag } from '@dxos/keys';
-
-/**
- * Gives access to all queues.
- */
-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 Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
-    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 Obj.Any | Relation.Any = Obj.Any | Relation.Any>(options?: {
-    subspaceTag?: QueueSubspaceTag;
-  }): Effect.Effect<Queue<T>, never, QueueService> =>
-    QueueService.pipe(Effect.map(({ queues }) => queues.create<T>(options)));
-
-  static append = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
-    queue: Queue<T>,
-    objects: T[],
-  ): Effect.Effect<void> => Effect.promise(() => queue.append(objects));
-}
-
-/**
- * Gives access to a specific queue passed as a context.
- */
-export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQueueService')<
-  ContextQueueService,
-  {
-    readonly queue: Queue;
-  }
->() {
-  static layer = (queue: Queue) => Layer.succeed(ContextQueueService, { queue });
-}
+export { ContextQueueService, QueueService, feedServiceFromQueueServiceLayer } from '@dxos/echo-db';

package/src/services/tracing.ts

@@ -2,142 +2,7 @@
 // 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 type { Queue } from '@dxos/echo-db';
-import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
-
-/**
- * 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> = { write: () => {}, getTraceContext: () => ({}) };
-
-  static layerNoop = Layer.succeed(TracingService, TracingService.noop);
-
-  static console: Context.Tag.Service<TracingService> = {
-    write: (event) => {
-      console.log(event);
-    },
-    getTraceContext: () => ({}),
-  };
-
-  static layerConsole = Layer.succeed(TracingService, TracingService.console);
-
-  static layerLogInfo = () =>
-    Layer.succeed(TracingService, {
-      write: (event) => {
-        if (Obj.instanceOf(AgentStatus, event)) {
-          log.info('status', { message: event.message });
-        }
-      },
-      getTraceContext: () => ({}),
-    });
-
-  /**
-   * 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,
-        };
-      }),
-    );
-
-  static layerQueue = (queue: Queue) =>
-    Layer.effect(
-      TracingService,
-      Effect.gen(function* () {
-        // TODO(dmaretskyi): Batching.
-        return {
-          write: (event) => queue.append([event]),
-          getTraceContext: () => ({
-            debugInfo: {
-              queue: queue.dxn.toString(),
-            },
-          }),
-        };
-      }),
-    );
-
-  /**
-   * 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 DataType.Message>,
-  ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
-    const tracing = yield* TracingService;
-    tracing.write(
-      Obj.make(DataType.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 DataType.Message['properties']}
+ * Goes into {@link Message['properties']}
  */
 export const MESSAGE_PROPERTY_TOOL_CALL_ID = 'toolCallId' as const;

package/src/types/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './url';

package/src/types/url.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Obj } from '@dxos/echo';
+
+// TODO: use URL scheme for source?
+export const FUNCTIONS_META_KEY = 'org.dxos.service.function';
+
+export const FUNCTIONS_PRESET_META_KEY = 'org.dxos.service.function-preset';
+
+/**
+ * NOTE: functionId is backend ID, not ECHO object id.
+ */
+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: Obj.Meta, functionId: string) => {
+  const key = meta.keys.find((key) => key.source === FUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionId) {
+      throw new Error('Metadata mismatch');
+    }
+  } else {
+    meta.keys.push({ source: FUNCTIONS_META_KEY, id: functionId });
+  }
+};