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

package/dist/lib/node-esm/{chunk-Z4CJ62WS.mjs → chunk-NAQIKLZB.mjs}

@@ -1,5 +1,32 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var ServiceNotAvailableError = class extends BaseError.extend("SERVICE_NOT_AVAILABLE", "Service not available") {
+  constructor(service, options) {
+    super({
+      context: {
+        service
+      },
+      ...options
+    });
+  }
+};
+var FunctionNotFoundError = class extends BaseError.extend("FUNCTION_NOT_FOUND", "Function not found") {
+  constructor(functionKey, options) {
+    super({
+      context: {
+        function: functionKey
+      },
+      ...options
+    });
+  }
+};
+var FunctionError = class extends BaseError.extend("FUNCTION_ERROR", "Function invocation error") {
+};
+var TriggerStateNotFoundError = class extends BaseError.extend("TRIGGER_STATE_NOT_FOUND", "Trigger state not found") {
+};
+
 // src/url.ts
 var FUNCTIONS_META_KEY = "dxos.org/service/function";
 var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
@@ -32,20 +59,23 @@ var getInvocationUrl = (functionId, edgeUrl, options = {}) => {
 };
 
 // src/services/database.ts
-import { Context, Effect, Layer, Option } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import { Obj, ObjectNotFoundError } from "@dxos/echo";
 import { promiseWithCauseCapture } from "@dxos/effect";
 import { invariant } from "@dxos/invariant";
-function _define_property(obj, key, value) {
+function _define_property(obj, key, value2) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
-      value,
+      value: value2,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
-    obj[key] = value;
+    obj[key] = value2;
   }
   return obj;
 }
@@ -80,7 +110,7 @@ _define_property(DatabaseService, "resolve", (dxn, schema) => Effect.gen(functio
   }
   invariant(!schema || Obj.instanceOf(schema, object), "Object type mismatch.", {
     F: __dxlog_file,
-    L: 78,
+    L: 82,
     S: this,
     A: [
       "!schema || Obj.instanceOf(schema, object)",
@@ -111,87 +141,45 @@ _define_property(DatabaseService, "runQuery", (queryOrFilter) => DatabaseService
 _define_property(DatabaseService, "schemaQuery", (query) => DatabaseService.pipe(Effect.map(({ db }) => db.schemaRegistry.query(query)), Effect.withSpan("DatabaseService.schemaQuery")));
 _define_property(DatabaseService, "runSchemaQuery", (query) => DatabaseService.schemaQuery(query).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run()))));
 
-// src/services/queues.ts
-import { Context as Context2, Effect as Effect2, Layer as Layer2 } from "effect";
-function _define_property2(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 _Context_Tag2;
-var QueueService = class extends (_Context_Tag2 = Context2.Tag("@dxos/functions/QueueService")()) {
-};
-_define_property2(QueueService, "notAvailable", Layer2.succeed(QueueService, {
-  queues: {
-    get(_dxn) {
-      throw new Error("Queues not available");
-    },
-    create() {
-      throw new Error("Queues not available");
-    }
-  },
-  queue: void 0
-}));
-_define_property2(QueueService, "make", (queues, queue) => {
-  return {
-    queues,
-    queue
-  };
-});
-_define_property2(QueueService, "layer", (queues, queue) => Layer2.succeed(QueueService, QueueService.make(queues, queue)));
-_define_property2(QueueService, "getQueue", (dxn) => QueueService.pipe(Effect2.map(({ queues }) => queues.get(dxn))));
-_define_property2(QueueService, "createQueue", (options) => QueueService.pipe(Effect2.map(({ queues }) => queues.create(options))));
-_define_property2(QueueService, "append", (queue, objects) => Effect2.promise(() => queue.append(objects)));
-var _Context_Tag1;
-var ContextQueueService = class extends (_Context_Tag1 = Context2.Tag("@dxos/functions/ContextQueueService")()) {
-};
-_define_property2(ContextQueueService, "layer", (queue) => Layer2.succeed(ContextQueueService, {
-  queue
-}));
-
 // src/services/credentials.ts
-import { HttpClient, HttpClientRequest } from "@effect/platform";
-import { Context as Context3, Effect as Effect3, Layer as Layer3, Redacted } from "effect";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Context2 from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import * as Redacted from "effect/Redacted";
 import { Query } from "@dxos/echo";
 import { DataType } from "@dxos/schema";
-function _define_property3(obj, key, value) {
+function _define_property2(obj, key, value2) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
-      value,
+      value: value2,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
-    obj[key] = value;
+    obj[key] = value2;
   }
   return obj;
 }
-var _Context_Tag3;
-var CredentialsService = class extends (_Context_Tag3 = Context3.Tag("@dxos/functions/CredentialsService")()) {
+var _Context_Tag2;
+var CredentialsService = class extends (_Context_Tag2 = Context2.Tag("@dxos/functions/CredentialsService")()) {
 };
-_define_property3(CredentialsService, "getCredential", (query) => Effect3.gen(function* () {
+_define_property2(CredentialsService, "getCredential", (query) => Effect2.gen(function* () {
   const credentials = yield* CredentialsService;
-  return yield* Effect3.promise(() => credentials.getCredential(query));
+  return yield* Effect2.promise(() => credentials.getCredential(query));
 }));
-_define_property3(CredentialsService, "getApiKey", (query) => Effect3.gen(function* () {
+_define_property2(CredentialsService, "getApiKey", (query) => Effect2.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);
 }));
-_define_property3(CredentialsService, "configuredLayer", (credentials) => Layer3.succeed(CredentialsService, new ConfiguredCredentialsService(credentials)));
-_define_property3(CredentialsService, "layerConfig", (credentials) => Layer3.effect(CredentialsService, Effect3.gen(function* () {
-  const serviceCredentials = yield* Effect3.forEach(credentials, ({ service, apiKey }) => Effect3.gen(function* () {
+_define_property2(CredentialsService, "configuredLayer", (credentials) => Layer2.succeed(CredentialsService, new ConfiguredCredentialsService(credentials)));
+_define_property2(CredentialsService, "layerConfig", (credentials) => Layer2.effect(CredentialsService, Effect2.gen(function* () {
+  const serviceCredentials = yield* Effect2.forEach(credentials, ({ service, apiKey }) => Effect2.gen(function* () {
     return {
       service,
       apiKey: Redacted.value(yield* apiKey)
@@ -199,7 +187,7 @@ _define_property3(CredentialsService, "layerConfig", (credentials) => Layer3.eff
   }));
   return new ConfiguredCredentialsService(serviceCredentials);
 })));
-_define_property3(CredentialsService, "layerFromDatabase", () => Layer3.effect(CredentialsService, Effect3.gen(function* () {
+_define_property2(CredentialsService, "layerFromDatabase", () => Layer2.effect(CredentialsService, Effect2.gen(function* () {
   const dbService = yield* DatabaseService;
   const queryCredentials = async (query) => {
     const { objects: accessTokens } = await dbService.db.query(Query.type(DataType.AccessToken)).run();
@@ -237,60 +225,62 @@ var ConfiguredCredentialsService = class {
     return credential;
   }
   constructor(credentials = []) {
-    _define_property3(this, "credentials", void 0);
+    _define_property2(this, "credentials", void 0);
     this.credentials = credentials;
   }
 };
-var withAuthorization = (query, kind) => HttpClient.mapRequestEffect(Effect3.fnUntraced(function* (request) {
-  const key = yield* CredentialsService.getApiKey(query).pipe(Effect3.map(Redacted.value));
+var withAuthorization = (query, kind) => HttpClient.mapRequestEffect(Effect2.fnUntraced(function* (request) {
+  const key = yield* CredentialsService.getApiKey(query).pipe(Effect2.map(Redacted.value));
   const authorization = kind ? `${kind} ${key}` : key;
   return HttpClientRequest.setHeader(request, "Authorization", authorization);
 }));
 
 // src/services/tracing.ts
-import { Context as Context4, Effect as Effect4, Layer as Layer4 } from "effect";
+import * as Context3 from "effect/Context";
+import * as Effect3 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
 import { AgentStatus } from "@dxos/ai";
 import { Obj as Obj2 } from "@dxos/echo";
 import { log } from "@dxos/log";
 import { DataType as DataType2 } from "@dxos/schema";
-function _define_property4(obj, key, value) {
+function _define_property3(obj, key, value2) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
-      value,
+      value: value2,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
-    obj[key] = value;
+    obj[key] = value2;
   }
   return obj;
 }
 var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/services/tracing.ts";
-var _Context_Tag4;
-var TracingService = class extends (_Context_Tag4 = Context4.Tag("@dxos/functions/TracingService")()) {
+var _Context_Tag3;
+var TracingService = class extends (_Context_Tag3 = Context3.Tag("@dxos/functions/TracingService")()) {
 };
-_define_property4(TracingService, "noop", {
+_define_property3(TracingService, "noop", {
   write: () => {
   },
   getTraceContext: () => ({})
 });
-_define_property4(TracingService, "layerNoop", Layer4.succeed(TracingService, TracingService.noop));
-_define_property4(TracingService, "console", {
+_define_property3(TracingService, "layerNoop", Layer3.succeed(TracingService, TracingService.noop));
+_define_property3(TracingService, "console", {
   write: (event) => {
     console.log(event);
   },
   getTraceContext: () => ({})
 });
-_define_property4(TracingService, "layerConsole", Layer4.succeed(TracingService, TracingService.console));
-_define_property4(TracingService, "layerLogInfo", () => Layer4.succeed(TracingService, {
+_define_property3(TracingService, "layerConsole", Layer3.succeed(TracingService, TracingService.console));
+_define_property3(TracingService, "layerLogInfo", () => Layer3.succeed(TracingService, {
   write: (event) => {
     if (Obj2.instanceOf(AgentStatus, event)) {
       log.info("status", {
         message: event.message
       }, {
         F: __dxlog_file2,
-        L: 51,
+        L: 52,
         S: TracingService,
         C: (f, a) => f(...a)
       });
@@ -298,7 +288,7 @@ _define_property4(TracingService, "layerLogInfo", () => Layer4.succeed(TracingSe
   },
   getTraceContext: () => ({})
 }));
-_define_property4(TracingService, "layerSubframe", (mapContext) => Layer4.effect(TracingService, Effect4.gen(function* () {
+_define_property3(TracingService, "layerSubframe", (mapContext) => Layer3.effect(TracingService, Effect3.gen(function* () {
   const tracing = yield* TracingService;
   const context = mapContext(tracing.getTraceContext());
   return {
@@ -306,7 +296,7 @@ _define_property4(TracingService, "layerSubframe", (mapContext) => Layer4.effect
     getTraceContext: () => context
   };
 })));
-_define_property4(TracingService, "layerQueue", (queue) => Layer4.effect(TracingService, Effect4.gen(function* () {
+_define_property3(TracingService, "layerQueue", (queue) => Layer3.effect(TracingService, Effect3.gen(function* () {
   return {
     write: (event) => queue.append([
       event
@@ -318,15 +308,16 @@ _define_property4(TracingService, "layerQueue", (queue) => Layer4.effect(Tracing
     })
   };
 })));
-_define_property4(TracingService, "emitStatus", Effect4.fnUntraced(function* (data) {
+_define_property3(TracingService, "emitStatus", Effect3.fnUntraced(function* (data) {
   const tracing = yield* TracingService;
   tracing.write(Obj2.make(AgentStatus, {
     parentMessage: tracing.getTraceContext().parentMessage,
     toolCallId: tracing.getTraceContext().toolCallId,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
     ...data
   }));
 }));
-_define_property4(TracingService, "emitConverationMessage", Effect4.fnUntraced(function* (data) {
+_define_property3(TracingService, "emitConverationMessage", Effect3.fnUntraced(function* (data) {
   const tracing = yield* TracingService;
   tracing.write(Obj2.make(DataType2.Message, {
     parentMessage: tracing.getTraceContext().parentMessage,
@@ -340,20 +331,23 @@ _define_property4(TracingService, "emitConverationMessage", Effect4.fnUntraced(f
 var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
 
 // src/services/event-logger.ts
-import { Context as Context5, Effect as Effect5, Layer as Layer5, Schema } from "effect";
+import * as Context4 from "effect/Context";
+import * as Effect4 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import * as Schema from "effect/Schema";
 import { Obj as Obj3, Type } from "@dxos/echo";
 import { invariant as invariant2 } from "@dxos/invariant";
 import { LogLevel, log as log2 } from "@dxos/log";
-function _define_property5(obj, key, value) {
+function _define_property4(obj, key, value2) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
-      value,
+      value: value2,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
-    obj[key] = value;
+    obj[key] = value2;
   }
   return obj;
 }
@@ -393,15 +387,15 @@ var ComputeEvent = Schema.Struct({
   typename: "dxos.org/type/ComputeEvent",
   version: "0.1.0"
 }));
-var _Context_Tag5;
-var ComputeEventLogger = class extends (_Context_Tag5 = Context5.Tag("@dxos/functions/ComputeEventLogger")()) {
+var _Context_Tag4;
+var ComputeEventLogger = class extends (_Context_Tag4 = Context4.Tag("@dxos/functions/ComputeEventLogger")()) {
 };
-_define_property5(ComputeEventLogger, "noop", {
+_define_property4(ComputeEventLogger, "noop", {
   log: () => {
   },
   nodeId: void 0
 });
-_define_property5(ComputeEventLogger, "layerFromTracing", Layer5.effect(ComputeEventLogger, Effect5.gen(function* () {
+_define_property4(ComputeEventLogger, "layerFromTracing", Layer4.effect(ComputeEventLogger, Effect4.gen(function* () {
   const tracing = yield* TracingService;
   return {
     log: (event) => {
@@ -412,7 +406,7 @@ _define_property5(ComputeEventLogger, "layerFromTracing", Layer5.effect(ComputeE
     nodeId: void 0
   };
 })));
-var logCustomEvent = (data) => Effect5.gen(function* () {
+var logCustomEvent = (data) => Effect4.gen(function* () {
   const logger = yield* ComputeEventLogger;
   if (!logger.nodeId) {
     throw new Error("logCustomEvent must be called within a node compute function");
@@ -423,12 +417,12 @@ var logCustomEvent = (data) => Effect5.gen(function* () {
     event: data
   });
 });
-var createDefectLogger = () => Effect5.catchAll((error) => Effect5.gen(function* () {
+var createDefectLogger = () => Effect4.catchAll((error) => Effect4.gen(function* () {
   log2.error("unhandled effect error", {
     error
   }, {
     F: __dxlog_file3,
-    L: 93,
+    L: 96,
     S: this,
     C: (f, a) => f(...a)
   });
@@ -444,7 +438,7 @@ var createEventLogger = (level, message = "event") => {
   }[level];
   invariant2(logFunction, void 0, {
     F: __dxlog_file3,
-    L: 111,
+    L: 114,
     S: void 0,
     A: [
       "logFunction",
@@ -459,69 +453,125 @@ var createEventLogger = (level, message = "event") => {
   };
 };
 
+// src/services/queues.ts
+import * as Context5 from "effect/Context";
+import * as Effect5 from "effect/Effect";
+import * as Layer5 from "effect/Layer";
+function _define_property5(obj, key, value2) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value2,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value2;
+  }
+  return obj;
+}
+var _Context_Tag5;
+var QueueService = class extends (_Context_Tag5 = Context5.Tag("@dxos/functions/QueueService")()) {
+};
+_define_property5(QueueService, "notAvailable", Layer5.succeed(QueueService, {
+  queues: {
+    get(_dxn) {
+      throw new Error("Queues not available");
+    },
+    create() {
+      throw new Error("Queues not available");
+    }
+  },
+  queue: void 0
+}));
+_define_property5(QueueService, "make", (queues, queue) => {
+  return {
+    queues,
+    queue
+  };
+});
+_define_property5(QueueService, "layer", (queues, queue) => Layer5.succeed(QueueService, QueueService.make(queues, queue)));
+_define_property5(QueueService, "getQueue", (dxn) => QueueService.pipe(Effect5.map(({ queues }) => queues.get(dxn))));
+_define_property5(QueueService, "createQueue", (options) => QueueService.pipe(Effect5.map(({ queues }) => queues.create(options))));
+_define_property5(QueueService, "append", (queue, objects) => Effect5.promise(() => queue.append(objects)));
+var _Context_Tag1;
+var ContextQueueService = class extends (_Context_Tag1 = Context5.Tag("@dxos/functions/ContextQueueService")()) {
+};
+_define_property5(ContextQueueService, "layer", (queue) => Layer5.succeed(ContextQueueService, {
+  queue
+}));
+
 // src/services/remote-function-execution-service.ts
-import { Context as Context6, Layer as Layer6 } from "effect";
-function _define_property6(obj, key, value) {
+import * as Context6 from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Layer6 from "effect/Layer";
+function _define_property6(obj, key, value2) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
-      value,
+      value: value2,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
-    obj[key] = value;
+    obj[key] = value2;
   }
   return obj;
 }
 var _Context_Tag6;
-var RemoteFunctionExecutionService = class extends (_Context_Tag6 = Context6.Tag("@dxos/functions/RemoteFunctionExecutionService")()) {
+var RemoteFunctionExecutionService = class _RemoteFunctionExecutionService extends (_Context_Tag6 = Context6.Tag("@dxos/functions/RemoteFunctionExecutionService")()) {
+  /**
+  * @param baseUrl URL of the EDGE server.
+  * @param spaceId - The space ID to invoke the function in. If not provided, the function will be without space context.
+  * @returns
+  */
   static fromClient(baseUrl, spaceId) {
-    return {
-      callFunction: async (deployedFunctionId, input) => {
+    return Layer6.succeed(_RemoteFunctionExecutionService, {
+      callFunction: (deployedFunctionId, input) => Effect6.gen(function* () {
         const url = getInvocationUrl(deployedFunctionId, baseUrl, {
           spaceId
         });
-        const result = await fetch(url, {
+        const result = yield* Effect6.promise(() => fetch(url, {
           method: "POST",
           headers: {
             "Content-Type": "application/json"
           },
           body: JSON.stringify(input)
-        });
+        }));
         if (result.status >= 300 || result.status < 200) {
-          throw new Error("Failed to invoke function", {
-            cause: new Error(`HTTP error: ${await result.text()}`)
-          });
+          const text = yield* Effect6.promise(() => result.text());
+          return yield* Effect6.die(new FunctionError({
+            message: "Failed to invoke function",
+            cause: new Error(`HTTP error: ${text}`)
+          }));
         }
-        return await result.json();
-      }
-    };
+        const data = yield* Effect6.promise(() => result.json());
+        return data;
+      })
+    });
   }
 };
 _define_property6(RemoteFunctionExecutionService, "mock", () => {
   return {
-    callFunction: async (deployedFunctionId, input) => {
-      return input;
-    }
+    callFunction: (deployedFunctionId, input) => Effect6.succeed(input)
   };
 });
-_define_property6(RemoteFunctionExecutionService, "mockLayer", Layer6.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock()));
+_define_property6(RemoteFunctionExecutionService, "layerMock", Layer6.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock()));
 
 // src/services/service-container.ts
-import { Layer as Layer7 } from "effect";
+import * as Layer7 from "effect/Layer";
 import { AiService } from "@dxos/ai";
 import { entries } from "@dxos/util";
-function _define_property7(obj, key, value) {
+function _define_property7(obj, key, value2) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
-      value,
+      value: value2,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
-    obj[key] = value;
+    obj[key] = value2;
   }
   return obj;
 }
@@ -587,14 +637,16 @@ var ServiceContainer = class _ServiceContainer {
 };
 
 export {
+  ServiceNotAvailableError,
+  FunctionNotFoundError,
+  FunctionError,
+  TriggerStateNotFoundError,
   FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
   getUserFunctionIdInMetadata,
   setUserFunctionIdInMetadata,
   getInvocationUrl,
   DatabaseService,
-  QueueService,
-  ContextQueueService,
   CredentialsService,
   ConfiguredCredentialsService,
   withAuthorization,
@@ -606,8 +658,10 @@ export {
   logCustomEvent,
   createDefectLogger,
   createEventLogger,
+  QueueService,
+  ContextQueueService,
   RemoteFunctionExecutionService,
   SERVICE_TAGS,
   ServiceContainer
 };
-//# sourceMappingURL=chunk-Z4CJ62WS.mjs.map
+//# sourceMappingURL=chunk-NAQIKLZB.mjs.map