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

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

@@ -5,80 +5,32 @@ 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';
 
+/**
+ * @deprecated
+ */
 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 { 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 });
+  }
+};

package/dist/lib/browser/bundler/index.mjs

@@ -1,269 +0,0 @@
-import "../chunk-J5LGTIGS.mjs";
-
-// src/bundler/bundler.ts
-import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Schedule from "effect/Schedule";
-import { build, initialize } from "esbuild-wasm";
-import { subtleCrypto } from "@dxos/crypto";
-import { runAndForwardErrors } from "@dxos/effect";
-import { invariant } from "@dxos/invariant";
-import { log } from "@dxos/log";
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/bundler/bundler.ts";
-var initialized;
-var initializeBundler = async (options) => {
-  await (initialized ?? (initialized = initialize({
-    wasmURL: options.wasmUrl
-  })));
-};
-var Bundler = class {
-  async bundle({ source }) {
-    const { sandboxedModules: providedModules, ...options } = this._options;
-    const sourceHash = Buffer.from(await subtleCrypto.digest("SHA-256", Buffer.from(source)));
-    if (this._options.platform === "browser") {
-      invariant(initialized, "Compiler not initialized.", {
-        F: __dxlog_file,
-        L: 70,
-        S: this,
-        A: [
-          "initialized",
-          "'Compiler not initialized.'"
-        ]
-      });
-      await initialized;
-    }
-    const imports = source ? analyzeSourceFileImports(source) : [];
-    try {
-      const result = await build({
-        platform: options.platform,
-        conditions: [
-          "workerd",
-          "browser"
-        ],
-        metafile: true,
-        write: false,
-        entryPoints: {
-          // Gets mapped to `userFunc.js` by esbuild.
-          userFunc: "memory:main.tsx"
-        },
-        bundle: true,
-        format: "esm",
-        plugins: [
-          {
-            name: "memory",
-            setup: (build2) => {
-              build2.onResolve({
-                filter: /^\.\/runtime\.js$/
-              }, ({ path }) => {
-                return {
-                  path,
-                  external: true
-                };
-              });
-              build2.onResolve({
-                filter: /^dxos:functions$/
-              }, ({ path }) => {
-                return {
-                  path: "./runtime.js",
-                  external: true
-                };
-              });
-              build2.onResolve({
-                filter: /^memory:/
-              }, ({ path }) => {
-                return {
-                  path: path.split(":")[1],
-                  namespace: "memory"
-                };
-              });
-              build2.onLoad({
-                filter: /.*/,
-                namespace: "memory"
-              }, ({ path }) => {
-                if (path === "main.tsx") {
-                  return {
-                    contents: source,
-                    loader: "tsx"
-                  };
-                }
-              });
-              for (const module of providedModules) {
-                build2.onResolve({
-                  filter: new RegExp(`^${module}$`)
-                }, ({ path }) => {
-                  return {
-                    path,
-                    namespace: "injected-module"
-                  };
-                });
-              }
-              build2.onLoad({
-                filter: /.*/,
-                namespace: "injected-module"
-              }, ({ path }) => {
-                const namedImports = imports.find((entry) => entry.moduleIdentifier === path)?.namedImports ?? [];
-                return {
-                  contents: `
-                  const { ${namedImports.join(",")} } = window.__DXOS_SANDBOX_MODULES__[${JSON.stringify(path)}];
-                  export { ${namedImports.join(",")} };
-                  export default window.__DXOS_SANDBOX_MODULES__[${JSON.stringify(path)}].default;
-                `,
-                  loader: "tsx"
-                };
-              });
-            }
-          },
-          httpPlugin
-        ]
-      });
-      log("compile complete", result.metafile, {
-        F: __dxlog_file,
-        L: 137,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const entryPoint = "userFunc.js";
-      return {
-        timestamp: Date.now(),
-        sourceHash,
-        imports: this.analyzeImports(result),
-        entryPoint,
-        asset: result.outputFiles[0].contents,
-        bundle: result.outputFiles[0].text
-      };
-    } catch (err) {
-      return {
-        timestamp: Date.now(),
-        sourceHash,
-        error: err
-      };
-    }
-  }
-  // TODO(dmaretskyi): In the future we can replace the compiler with SWC with plugins running in WASM.
-  analyzeImports(result) {
-    invariant(result.outputFiles, void 0, {
-      F: __dxlog_file,
-      L: 155,
-      S: this,
-      A: [
-        "result.outputFiles",
-        ""
-      ]
-    });
-    const parsedImports = allMatches(IMPORT_REGEX, result.outputFiles[0].text);
-    return Object.values(result.metafile.outputs)[0].imports.map((entry) => {
-      const namedImports = [];
-      const parsedImport = parsedImports.find((capture) => capture?.[4] === entry.path);
-      if (parsedImport?.[2]) {
-        NAMED_IMPORTS_REGEX.lastIndex = 0;
-        const namedImportsMatch = NAMED_IMPORTS_REGEX.exec(parsedImport[2]);
-        if (namedImportsMatch) {
-          namedImportsMatch[1].split(",").forEach((importName) => {
-            namedImports.push(importName.trim());
-          });
-        }
-      }
-      return {
-        moduleUrl: entry.path,
-        defaultImport: !!parsedImport?.[1],
-        namedImports
-      };
-    });
-  }
-  analyzeSourceFileImports(code) {
-    const parsedImports = allMatches(IMPORT_REGEX, code);
-    return parsedImports.map((capture) => {
-      return {
-        defaultImportName: capture[1],
-        namedImports: capture[2]?.split(",").map((importName) => importName.trim()),
-        wildcardImportName: capture[3],
-        moduleIdentifier: capture[4],
-        quotes: capture[5]
-      };
-    });
-  }
-  constructor(_options) {
-    _define_property(this, "_options", void 0);
-    this._options = _options;
-  }
-};
-var IMPORT_REGEX = /import(?:(?:(?:[ \n\t]+([^ *\n\t{},]+)[ \n\t]*(?:,|[ \n\t]+))?([ \n\t]*{(?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+})?[ \n\t]*)|[ \n\t]*\*[ \n\t]*as[ \n\t]+([^ \n\t{}]+)[ \n\t]+)from[ \n\t]*(?:['"])([^'"\n]+)(['"])/gm;
-var NAMED_IMPORTS_REGEX = /[ \n\t]*{((?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+)}[ \n\t]*/gm;
-var allMatches = (regex, str) => {
-  let match;
-  const matches = [];
-  regex.lastIndex = 0;
-  while (match = regex.exec(str)) {
-    matches.push(match);
-  }
-  return matches;
-};
-var analyzeSourceFileImports = (code) => {
-  const parsedImports = allMatches(IMPORT_REGEX, code);
-  return parsedImports.map((capture) => {
-    return {
-      defaultImportName: capture[1],
-      namedImports: capture[2]?.trim().slice(1, -1).split(",").map((importName) => importName.trim()),
-      wildcardImportName: capture[3],
-      moduleIdentifier: capture[4],
-      quotes: capture[5]
-    };
-  });
-};
-var MAX_RETRIES = 5;
-var INITIAL_DELAY = 1e3;
-var httpPlugin = {
-  name: "http",
-  setup: (build2) => {
-    build2.onResolve({
-      filter: /^https?:\/\//
-    }, (args) => ({
-      path: args.path,
-      namespace: "http-url"
-    }));
-    build2.onResolve({
-      filter: /.*/,
-      namespace: "http-url"
-    }, (args) => ({
-      path: new URL(args.path, args.importer).toString(),
-      namespace: "http-url"
-    }));
-    build2.onLoad({
-      filter: /.*/,
-      namespace: "http-url"
-    }, async (args) => {
-      return Effect.gen(function* () {
-        const response = yield* HttpClient.get(args.path);
-        if (response.status !== 200) {
-          throw new Error(`failed to fetch: ${response.status}`);
-        }
-        const text = yield* response.text;
-        return {
-          contents: text,
-          loader: "jsx"
-        };
-      }).pipe(Effect.retry(Function.pipe(Schedule.exponential(Duration.millis(INITIAL_DELAY)), Schedule.jittered, Schedule.intersect(Schedule.recurs(MAX_RETRIES - 1)))), Effect.provide(FetchHttpClient.layer), runAndForwardErrors);
-    });
-  }
-};
-export {
-  Bundler,
-  initializeBundler
-};
-//# sourceMappingURL=index.mjs.map