@dxos/functions 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/src/sdk.ts

@@ -3,37 +3,29 @@
 //
 
 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;
+  // 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,136 +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 { Database } from '@dxos/echo';
+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 = ({ 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 +44,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 { QueueService, feedServiceFromQueueServiceLayer } from '@dxos/echo-db';

package/src/services/tracing.ts

@@ -2,198 +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 { type DXN, Obj, Ref } from '@dxos/echo';
-import { ObjectId } from '@dxos/keys';
-import { Message } from '@dxos/types';
-
-import type { Trigger } from '../types';
-
-/**
- * Provides a way for compute primitives (functions, workflows, tools)
- * to emit an execution trace as a series of structured ECHO objects.
- * @deprecated Use Trace.TraceService instead.
- */
-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.Unknown, traceContext: TracingService.TraceContext) => void;
-
-    /**
-     * Write an ephemeral event.
-     */
-    ephemeral: (event: Obj.Unknown, traceContext: TracingService.TraceContext) => void;
-
-    traceInvocationStart({
-      payload,
-      target,
-    }: {
-      payload: TracingService.FunctionInvocationPayload;
-      target?: DXN;
-    }): Effect.Effect<TracingService.InvocationTraceData>;
-
-    traceInvocationEnd({
-      trace,
-      exception,
-    }: {
-      trace: TracingService.InvocationTraceData;
-      exception?: any;
-    }): Effect.Effect<void>;
-  }
->() {
-  static noop: Context.Tag.Service<TracingService> = {
-    getTraceContext: () => ({}),
-    write: () => {},
-    ephemeral: () => {},
-    traceInvocationStart: () =>
-      Effect.sync(() => ({ invocationId: ObjectId.random(), invocationTraceQueue: undefined })),
-    traceInvocationEnd: () => Effect.sync(() => {}),
-  };
-
-  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, context) => tracing.write(event, context),
-          ephemeral: (event, context) => tracing.ephemeral(event, context),
-          getTraceContext: () => context,
-          traceInvocationStart: () => Effect.die('Tracing invocation inside another invocation is not supported.'),
-          traceInvocationEnd: () => Effect.die('Tracing invocation inside another invocation is not supported.'),
-        };
-      }),
-    );
-
-  /**
-   * Create sublayer to trace an invocation.
-   * @param data
-   * @returns
-   */
-  static layerInvocation = (data: TracingService.InvocationTraceData) =>
-    TracingService.layerSubframe((context) => ({
-      ...context,
-      currentInvocation: data,
-    }));
-
-  /**
-   * 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,
-      }),
-      tracing.getTraceContext(),
-    );
-  });
-
-  static emitConverationMessage: (
-    data: Obj.MakeProps<typeof Message.Message> | 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,
-        },
-      }),
-      tracing.getTraceContext(),
-    );
-  });
-
-  static emitEphemeralMessage: (data: Message.Message) => Effect.Effect<void, never, TracingService> =
-    Effect.fnUntraced(function* (data) {
-      const tracing = yield* TracingService;
-      tracing.ephemeral(data, tracing.getTraceContext());
-    });
-}
-
-export namespace TracingService {
-  export interface TraceContext {
-    currentInvocation?: InvocationTraceData;
-
-    /**
-     * 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;
-  }
-
-  /**
-   * Trace data for a function/trigger invocation.
-   */
-  export interface InvocationTraceData {
-    invocationId: ObjectId;
-    invocationTraceQueue?: DXN.String;
-  }
-
-  /**
-   * Payload for a function/trigger invocation.
-   */
-  export interface FunctionInvocationPayload {
-    data?: any;
-    inputNodeId?: string;
-    trigger?: {
-      id: string;
-      kind: Trigger.Kind;
-    };
-    chat?: Ref.Ref<Obj.Unknown>;
-    process?: {
-      pid: string;
-      parentPid?: string;
-      /**
-       * Key of the executable.
-       */
-      key: string;
-
-      /**
-       * Process name.
-       */
-      name?: string;
-
-      /**
-       * Target object that the process is assigned to.
-       */
-      target?: string;
-    };
-  }
-}
-
 /**
  * Goes into {@link Message['properties']}
  */

package/src/types/index.ts

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

package/src/types/url.ts

@@ -18,7 +18,7 @@ export const getUserFunctionIdInMetadata = (meta: Obj.ReadonlyMeta) => {
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
- * Must be called inside Obj.changeMeta() since it mutates the meta.
+ * 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);

package/dist/lib/neutral/Trace.mjs

@@ -1,38 +0,0 @@
-import {
-  Event,
-  EventType,
-  Message,
-  MessageData,
-  Meta,
-  OperationEnd,
-  OperationStart,
-  TraceService,
-  TraceSink,
-  isOfType,
-  layerConsole,
-  layerNoop,
-  noopWriter,
-  testTraceService,
-  write,
-  writerLayerNoop
-} from "./chunk-5T7GOX2V.mjs";
-import "./chunk-J5LGTIGS.mjs";
-export {
-  Event,
-  EventType,
-  Message,
-  MessageData,
-  Meta,
-  OperationEnd,
-  OperationStart,
-  TraceService,
-  TraceSink,
-  isOfType,
-  layerConsole,
-  layerNoop,
-  noopWriter,
-  testTraceService,
-  write,
-  writerLayerNoop
-};
-//# sourceMappingURL=Trace.mjs.map

package/dist/lib/neutral/Trace.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
-}