@dxos/functions 0.8.4-main.e8ec1fe → 0.8.4-main.ef1bc66f44

package/dist/lib/node-esm/index.mjs

@@ -1,928 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// 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/example/fib.ts
-import * as Effect2 from "effect/Effect";
-import * as Schema6 from "effect/Schema";
-
-// src/sdk.ts
-import * as Effect from "effect/Effect";
-import * as Schema5 from "effect/Schema";
-import { Obj as Obj5, Type as Type5 } from "@dxos/echo";
-import { assertArgument, failedInvariant } from "@dxos/invariant";
-
-// src/types/Function.ts
-var Function_exports = {};
-__export(Function_exports, {
-  Function: () => Function,
-  make: () => make2
-});
-import * as Schema2 from "effect/Schema";
-import { Obj as Obj2, Type as Type2 } from "@dxos/echo";
-import { JsonSchemaType, LabelAnnotation as LabelAnnotation2, Ref as Ref2 } from "@dxos/echo/internal";
-
-// src/types/Script.ts
-var Script_exports = {};
-__export(Script_exports, {
-  Script: () => Script,
-  make: () => make
-});
-import * as Schema from "effect/Schema";
-import { Obj, Ref, Type } from "@dxos/echo";
-import { FormAnnotation, LabelAnnotation } from "@dxos/echo/internal";
-import { Text } from "@dxos/schema";
-var Script = Schema.Struct({
-  name: Schema.String.pipe(Schema.optional),
-  description: Schema.String.pipe(Schema.optional),
-  // TODO(burdon): Change to hash of deployed content.
-  // Whether source has changed since last deploy.
-  changed: Schema.Boolean.pipe(FormAnnotation.set(false), Schema.optional),
-  source: Type.Ref(Text.Text).pipe(FormAnnotation.set(false))
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/Script",
-  version: "0.1.0"
-}), LabelAnnotation.set([
-  "name"
-]));
-var make = ({ source = "", ...props } = {}) => Obj.make(Script, {
-  ...props,
-  source: Ref.make(Text.make(source))
-});
-
-// src/types/Function.ts
-var Function = Schema2.Struct({
-  /**
-  * Global registry ID.
-  * NOTE: The `key` property refers to the original registry entry.
-  */
-  // TODO(burdon): Create Format type for DXN-like ids, such as this and schema type.
-  // TODO(dmaretskyi): Consider making it part of ECHO meta.
-  // TODO(dmaretskyi): Make required.
-  key: Schema2.optional(Schema2.String).annotations({
-    description: "Unique registration key for the blueprint"
-  }),
-  // TODO(burdon): Rename to id/uri?
-  name: Schema2.NonEmptyString,
-  version: Schema2.String,
-  description: Schema2.optional(Schema2.String),
-  /**
-  * ISO date string of the last deployment.
-  */
-  updated: Schema2.optional(Schema2.String),
-  // Reference to a source script if it exists within ECHO.
-  // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema2.optional(Ref2(Script)),
-  inputSchema: Schema2.optional(JsonSchemaType),
-  outputSchema: Schema2.optional(JsonSchemaType),
-  /**
-  * List of required services.
-  * Match the Context.Tag keys of the FunctionServices variants.
-  */
-  services: Schema2.optional(Schema2.Array(Schema2.String)),
-  // Local binding to a function name.
-  binding: Schema2.optional(Schema2.String)
-}).pipe(Type2.Obj({
-  typename: "dxos.org/type/Function",
-  version: "0.1.0"
-}), LabelAnnotation2.set([
-  "name"
-]));
-var make2 = (props) => Obj2.make(Function, props);
-
-// src/types/Trigger.ts
-var Trigger_exports = {};
-__export(Trigger_exports, {
-  EmailSpec: () => EmailSpec,
-  Kinds: () => Kinds,
-  QueueSpec: () => QueueSpec,
-  Spec: () => Spec,
-  SubscriptionSpec: () => SubscriptionSpec,
-  TimerSpec: () => TimerSpec,
-  Trigger: () => Trigger,
-  WebhookSpec: () => WebhookSpec,
-  make: () => make3
-});
-import * as Schema3 from "effect/Schema";
-import * as SchemaAST from "effect/SchemaAST";
-import { Obj as Obj3, QueryAST, Type as Type3 } from "@dxos/echo";
-import { Expando, OptionsAnnotationId, Ref as Ref3 } from "@dxos/echo/internal";
-import { DXN } from "@dxos/keys";
-var Kinds = [
-  "email",
-  "queue",
-  "subscription",
-  "timer",
-  "webhook"
-];
-var kindLiteralAnnotations = {
-  title: "Kind"
-};
-var EmailSpec = Schema3.Struct({
-  kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
-}).pipe(Schema3.mutable);
-var QueueSpec = Schema3.Struct({
-  kind: Schema3.Literal("queue").annotations(kindLiteralAnnotations),
-  // TODO(dmaretskyi): Change to a reference.
-  queue: DXN.Schema
-}).pipe(Schema3.mutable);
-var SubscriptionSpec = Schema3.Struct({
-  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
-  query: Schema3.Struct({
-    raw: Schema3.optional(Schema3.String.annotations({
-      title: "Query"
-    })),
-    ast: QueryAST.Query
-  }).pipe(Schema3.mutable),
-  options: Schema3.optional(Schema3.Struct({
-    // Watch changes to object (not just creation).
-    deep: Schema3.optional(Schema3.Boolean.annotations({
-      title: "Nested"
-    })),
-    // Debounce changes (delay in ms).
-    delay: Schema3.optional(Schema3.Number.annotations({
-      title: "Delay"
-    }))
-  }).annotations({
-    title: "Options"
-  }))
-}).pipe(Schema3.mutable);
-var TimerSpec = Schema3.Struct({
-  kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema3.String.annotations({
-    title: "Cron",
-    [SchemaAST.ExamplesAnnotationId]: [
-      "0 0 * * *"
-    ]
-  })
-}).pipe(Schema3.mutable);
-var WebhookSpec = Schema3.Struct({
-  kind: Schema3.Literal("webhook").annotations(kindLiteralAnnotations),
-  method: Schema3.optional(Schema3.String.annotations({
-    title: "Method",
-    [OptionsAnnotationId]: [
-      "GET",
-      "POST"
-    ]
-  })),
-  port: Schema3.optional(Schema3.Number.annotations({
-    title: "Port"
-  }))
-}).pipe(Schema3.mutable);
-var Spec = Schema3.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
-  title: "Trigger"
-});
-var Trigger_ = Schema3.Struct({
-  /**
-  * Function or workflow to invoke.
-  */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema3.optional(Ref3(Expando).annotations({
-    title: "Function"
-  })),
-  /**
-  * Only used for workflowSchema.
-  * Specifies the input node in the circuit.
-  * @deprecated Remove and enforce a single input node in all compute graphSchema.
-  */
-  inputNodeId: Schema3.optional(Schema3.String.annotations({
-    title: "Input Node ID"
-  })),
-  enabled: Schema3.optional(Schema3.Boolean.annotations({
-    title: "Enabled"
-  })),
-  spec: Schema3.optional(Spec),
-  /**
-  * Passed as the input data to the function.
-  * Must match the function's input schema.
-  *
-  * @example
-  * {
-  *   item: '{{$.trigger.event}}',
-  *   instructions: 'Summarize and perform entity-extraction'
-  *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
-  * }
-  */
-  input: Schema3.optional(Schema3.mutable(Schema3.Record({
-    key: Schema3.String,
-    value: Schema3.Any
-  })))
-}).pipe(Type3.Obj({
-  typename: "dxos.org/type/Trigger",
-  version: "0.1.0"
-}));
-var Trigger = Trigger_;
-var make3 = (props) => Obj3.make(Trigger, props);
-
-// src/types/TriggerEvent.ts
-var TriggerEvent_exports = {};
-__export(TriggerEvent_exports, {
-  EmailEvent: () => EmailEvent,
-  QueueEvent: () => QueueEvent,
-  SubscriptionEvent: () => SubscriptionEvent,
-  TimerEvent: () => TimerEvent,
-  WebhookEvent: () => WebhookEvent
-});
-import * as Schema4 from "effect/Schema";
-import { DXN as DXN2, Obj as Obj4, Type as Type4 } from "@dxos/echo";
-var EmailEvent = Schema4.mutable(Schema4.Struct({
-  from: Schema4.String,
-  to: Schema4.String,
-  subject: Schema4.String,
-  created: Schema4.String,
-  body: Schema4.String
-}));
-var QueueEvent = Schema4.mutable(Schema4.Struct({
-  queue: DXN2.Schema,
-  item: Schema4.Any,
-  cursor: Schema4.String
-}));
-var SubscriptionEvent = Schema4.Struct({
-  /**
-  * Type of the mutation.
-  */
-  // TODO(dmaretskyi): Specify enum.
-  type: Schema4.String,
-  /**
-  * Reference to the object that was changed or created.
-  */
-  subject: Type4.Ref(Obj4.Any),
-  /**
-  * @deprecated
-  */
-  changedObjectId: Schema4.optional(Schema4.String)
-}).pipe(Schema4.mutable);
-var TimerEvent = Schema4.mutable(Schema4.Struct({
-  tick: Schema4.Number
-}));
-var WebhookEvent = Schema4.mutable(Schema4.Struct({
-  url: Schema4.String,
-  method: Schema4.Literal("GET", "POST"),
-  headers: Schema4.Record({
-    key: Schema4.String,
-    value: Schema4.String
-  }),
-  bodyText: Schema4.String
-}));
-
-// src/types/url.ts
-var FUNCTIONS_META_KEY = "dxos.org/service/function";
-var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
-var getUserFunctionIdInMetadata = (meta) => {
-  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
-};
-var setUserFunctionIdInMetadata = (meta, functionId) => {
-  const key = meta.keys.find((key2) => key2.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
-    });
-  }
-};
-
-// src/sdk.ts
-var typeId = Symbol.for("@dxos/functions/FunctionDefinition");
-var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler, services }) => {
-  if (!Schema5.isSchema(inputSchema)) {
-    throw new Error("Input schema must be a valid schema");
-  }
-  if (typeof handler !== "function") {
-    throw new Error("Handler must be a function");
-  }
-  const limit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 2;
-  const traceError = new Error();
-  Error.stackTraceLimit = limit;
-  let cache = false;
-  const captureStackTrace = () => {
-    if (cache !== false) {
-      return cache;
-    }
-    if (traceError.stack !== void 0) {
-      const stack = traceError.stack.split("\n");
-      if (stack[2] !== void 0) {
-        cache = stack[2].trim();
-        return cache;
-      }
-    }
-  };
-  const handlerWithSpan = (...args) => {
-    const result = handler(...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)
-  };
-};
-var getServiceKeys = (services) => {
-  return services.map((tag) => {
-    if (typeof tag.key === "string") {
-      return tag.key;
-    }
-    console.log(tag);
-    failedInvariant();
-  });
-};
-var FunctionDefinition = {
-  make: defineFunction,
-  isFunction: (value2) => {
-    return typeof value2 === "object" && value2 !== null && Symbol.for("@dxos/functions/FunctionDefinition") in value2;
-  },
-  serialize: (functionDef) => {
-    assertArgument(FunctionDefinition.isFunction(functionDef), "functionDef");
-    return serializeFunction(functionDef);
-  },
-  deserialize: (functionObj) => {
-    assertArgument(Obj5.instanceOf(Function_exports.Function, functionObj), "functionObj");
-    return deserializeFunction(functionObj);
-  }
-};
-var serializeFunction = (functionDef) => {
-  const fn4 = Function_exports.make({
-    key: functionDef.key,
-    name: functionDef.name,
-    version: "0.1.0",
-    description: functionDef.description,
-    inputSchema: Type5.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? void 0 : Type5.toJsonSchema(functionDef.outputSchema),
-    services: functionDef.services
-  });
-  if (functionDef.meta?.deployedFunctionId) {
-    setUserFunctionIdInMetadata(Obj5.getMeta(fn4), functionDef.meta.deployedFunctionId);
-  }
-  return fn4;
-};
-var deserializeFunction = (functionObj) => {
-  return {
-    [typeId]: true,
-    // TODO(dmaretskyi): Fix key.
-    key: functionObj.key ?? functionObj.name,
-    name: functionObj.name,
-    description: functionObj.description,
-    inputSchema: !functionObj.inputSchema ? Schema5.Unknown : Type5.toEffectSchema(functionObj.inputSchema),
-    outputSchema: !functionObj.outputSchema ? void 0 : Type5.toEffectSchema(functionObj.outputSchema),
-    // TODO(dmaretskyi): This should throw error.
-    handler: () => {
-    },
-    services: functionObj.services ?? [],
-    meta: {
-      deployedFunctionId: getUserFunctionIdInMetadata(Obj5.getMeta(functionObj))
-    }
-  };
-};
-
-// src/example/fib.ts
-var fib_default = defineFunction({
-  key: "example.org/function/fib",
-  name: "Fibonacci",
-  description: "Function that calculates a Fibonacci number",
-  inputSchema: Schema6.Struct({
-    iterations: Schema6.optional(Schema6.Number).annotations({
-      description: "Number of iterations",
-      default: 1e5
-    })
-  }),
-  outputSchema: Schema6.Struct({
-    result: Schema6.String
-  }),
-  handler: Effect2.fn(function* ({ data: { iterations = 1e5 } }) {
-    let a = 0n;
-    let b = 1n;
-    for (let i = 0; i < iterations; i++) {
-      a += b;
-      b = a - b;
-    }
-    return {
-      result: a.toString()
-    };
-  })
-});
-
-// src/example/reply.ts
-import * as Console from "effect/Console";
-import * as Effect3 from "effect/Effect";
-import * as Schema7 from "effect/Schema";
-var reply_default = defineFunction({
-  key: "example.org/function/reply",
-  name: "Reply",
-  description: "Function that echoes the input",
-  inputSchema: Schema7.Any,
-  outputSchema: Schema7.Any,
-  handler: Effect3.fn(function* ({ data }) {
-    yield* Console.log("reply", {
-      data
-    });
-    return data;
-  })
-});
-
-// src/example/sleep.ts
-import * as Effect4 from "effect/Effect";
-import * as Schema8 from "effect/Schema";
-var sleep_default = defineFunction({
-  key: "example.org/function/sleep",
-  name: "Sleep",
-  description: "Function that sleeps for a given amount of time",
-  inputSchema: Schema8.Struct({
-    duration: Schema8.optional(Schema8.Number).annotations({
-      description: "Milliseconds to sleep",
-      default: 1e5
-    })
-  }),
-  outputSchema: Schema8.Void,
-  handler: Effect4.fn(function* ({ data: { duration = 1e5 } }) {
-    yield* Effect4.sleep(duration);
-  })
-});
-
-// src/example/index.ts
-(function(Example2) {
-  Example2.fib = fib_default;
-  Example2.reply = reply_default;
-  Example2.sleep = sleep_default;
-})(Example || (Example = {}));
-var Example;
-
-// src/services/index.ts
-import { DatabaseService as DatabaseService2 } from "@dxos/echo-db";
-
-// src/services/credentials.ts
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as Context from "effect/Context";
-import * as Effect5 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 { AccessToken } from "@dxos/types";
-var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/functions/CredentialsService")() {
-  static getCredential = (query) => Effect5.gen(function* () {
-    const credentials = yield* _CredentialsService;
-    return yield* Effect5.promise(() => credentials.getCredential(query));
-  });
-  static getApiKey = (query) => Effect5.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) => Layer.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
-  static layerConfig = (credentials) => Layer.effect(_CredentialsService, Effect5.gen(function* () {
-    const serviceCredentials = yield* Effect5.forEach(credentials, ({ service, apiKey }) => Effect5.gen(function* () {
-      return {
-        service,
-        apiKey: Redacted.value(yield* apiKey)
-      };
-    }));
-    return new ConfiguredCredentialsService(serviceCredentials);
-  }));
-  static layerFromDatabase = () => Layer.effect(_CredentialsService, Effect5.gen(function* () {
-    const dbService = yield* DatabaseService;
-    const queryCredentials = async (query) => {
-      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);
-      }
-    };
-  }));
-};
-var ConfiguredCredentialsService = class {
-  credentials;
-  constructor(credentials = []) {
-    this.credentials = credentials;
-  }
-  addCredentials(credentials) {
-    this.credentials.push(...credentials);
-    return this;
-  }
-  async queryCredentials(query) {
-    return this.credentials.filter((credential) => credential.service === query.service);
-  }
-  async getCredential(query) {
-    const credential = this.credentials.find((credential2) => credential2.service === query.service);
-    if (!credential) {
-      throw new Error(`Credential not found for service: ${query.service}`);
-    }
-    return credential;
-  }
-};
-var withAuthorization = (query, kind) => HttpClient.mapRequestEffect(Effect5.fnUntraced(function* (request) {
-  const key = yield* CredentialsService.getApiKey(query).pipe(Effect5.map(Redacted.value));
-  const authorization = kind ? `${kind} ${key}` : key;
-  return HttpClientRequest.setHeader(request, "Authorization", authorization);
-}));
-
-// src/services/event-logger.ts
-import * as Context3 from "effect/Context";
-import * as Effect7 from "effect/Effect";
-import * as Layer3 from "effect/Layer";
-import * as Schema9 from "effect/Schema";
-import { Obj as Obj7, Type as Type6 } from "@dxos/echo";
-import { invariant } from "@dxos/invariant";
-import { LogLevel, log as log2 } from "@dxos/log";
-
-// src/services/tracing.ts
-import * as Context2 from "effect/Context";
-import * as Effect6 from "effect/Effect";
-import * as Layer2 from "effect/Layer";
-import { AgentStatus } from "@dxos/ai";
-import { Obj as Obj6 } from "@dxos/echo";
-import { Message } from "@dxos/types";
-var TracingService = class _TracingService extends Context2.Tag("@dxos/functions/TracingService")() {
-  static noop = {
-    getTraceContext: () => ({}),
-    write: () => {
-    }
-  };
-  static layerNoop = Layer2.succeed(_TracingService, _TracingService.noop);
-  /**
-  * Creates a TracingService layer that emits events to the parent tracing service.
-  */
-  static layerSubframe = (mapContext) => Layer2.effect(_TracingService, Effect6.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 = Effect6.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj6.make(AgentStatus, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      toolCallId: tracing.getTraceContext().toolCallId,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      ...data
-    }));
-  });
-  static emitConverationMessage = Effect6.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj6.make(Message.Message, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      ...data,
-      properties: {
-        [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
-        ...data.properties
-      }
-    }));
-  });
-};
-var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
-
-// src/services/event-logger.ts
-var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/event-logger.ts";
-var ComputeEventPayload = Schema9.Union(Schema9.Struct({
-  type: Schema9.Literal("begin-compute"),
-  nodeId: Schema9.String,
-  /**
-   * Names of the inputs begin computed.
-   */
-  inputs: Schema9.Array(Schema9.String)
-}), Schema9.Struct({
-  type: Schema9.Literal("end-compute"),
-  nodeId: Schema9.String,
-  /**
-   * Names of the outputs computed.
-   */
-  outputs: Schema9.Array(Schema9.String)
-}), Schema9.Struct({
-  type: Schema9.Literal("compute-input"),
-  nodeId: Schema9.String,
-  property: Schema9.String,
-  value: Schema9.Any
-}), Schema9.Struct({
-  type: Schema9.Literal("compute-output"),
-  nodeId: Schema9.String,
-  property: Schema9.String,
-  value: Schema9.Any
-}), Schema9.Struct({
-  type: Schema9.Literal("custom"),
-  nodeId: Schema9.String,
-  event: Schema9.Any
-}));
-var ComputeEvent = Schema9.Struct({
-  payload: ComputeEventPayload
-}).pipe(Type6.Obj({
-  typename: "dxos.org/type/ComputeEvent",
-  version: "0.1.0"
-}));
-var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/functions/ComputeEventLogger")() {
-  static noop = {
-    log: () => {
-    },
-    nodeId: void 0
-  };
-  /**
-  * Implements ComputeEventLogger using TracingService.
-  */
-  static layerFromTracing = Layer3.effect(_ComputeEventLogger, Effect7.gen(function* () {
-    const tracing = yield* TracingService;
-    return {
-      log: (event) => {
-        tracing.write(Obj7.make(ComputeEvent, {
-          payload: event
-        }));
-      },
-      nodeId: void 0
-    };
-  }));
-};
-var logCustomEvent = (data) => Effect7.gen(function* () {
-  const logger = yield* ComputeEventLogger;
-  if (!logger.nodeId) {
-    throw new Error("logCustomEvent must be called within a node compute function");
-  }
-  logger.log({
-    type: "custom",
-    nodeId: logger.nodeId,
-    event: data
-  });
-});
-var createDefectLogger = () => Effect7.catchAll((error) => Effect7.gen(function* () {
-  log2.error("unhandled effect error", {
-    error
-  }, {
-    F: __dxlog_file,
-    L: 102,
-    S: this,
-    C: (f, a) => f(...a)
-  });
-  throw error;
-}));
-var createEventLogger = (level, message = "event") => {
-  const logFunction = {
-    [LogLevel.WARN]: log2.warn,
-    [LogLevel.VERBOSE]: log2.verbose,
-    [LogLevel.DEBUG]: log2.debug,
-    [LogLevel.INFO]: log2.info,
-    [LogLevel.ERROR]: log2.error
-  }[level];
-  invariant(logFunction, void 0, {
-    F: __dxlog_file,
-    L: 120,
-    S: void 0,
-    A: [
-      "logFunction",
-      ""
-    ]
-  });
-  return {
-    log: (event) => {
-      logFunction(message, event);
-    },
-    nodeId: void 0
-  };
-};
-
-// src/services/function-invocation-service.ts
-import * as Context4 from "effect/Context";
-import * as Effect8 from "effect/Effect";
-var FunctionInvocationService = class _FunctionInvocationService extends Context4.Tag("@dxos/functions/FunctionInvocationService")() {
-  static invokeFunction = (functionDef, input) => Effect8.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
-};
-
-// src/services/queues.ts
-import * as Context5 from "effect/Context";
-import * as Effect9 from "effect/Effect";
-import * as Layer4 from "effect/Layer";
-var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/QueueService")() {
-  static notAvailable = Layer4.succeed(_QueueService, {
-    queues: {
-      get(_dxn) {
-        throw new Error("Queues not available");
-      },
-      create() {
-        throw new Error("Queues not available");
-      }
-    },
-    queue: void 0
-  });
-  static make = (queues, queue) => {
-    return {
-      queues,
-      queue
-    };
-  };
-  static layer = (queues, queue) => Layer4.succeed(_QueueService, _QueueService.make(queues, queue));
-  /**
-  * Gets a queue by its DXN.
-  */
-  static getQueue = (dxn) => _QueueService.pipe(Effect9.map(({ queues }) => queues.get(dxn)));
-  /**
-  * Creates a new queue.
-  */
-  static createQueue = (options) => _QueueService.pipe(Effect9.map(({ queues }) => queues.create(options)));
-  static append = (queue, objects) => Effect9.promise(() => queue.append(objects));
-};
-var ContextQueueService = class _ContextQueueService extends Context5.Tag("@dxos/functions/ContextQueueService")() {
-  static layer = (queue) => Layer4.succeed(_ContextQueueService, {
-    queue
-  });
-};
-
-// src/protocol/protocol.ts
-import * as Effect10 from "effect/Effect";
-import * as Layer5 from "effect/Layer";
-import * as Schema10 from "effect/Schema";
-import * as SchemaAST2 from "effect/SchemaAST";
-import { AiService } from "@dxos/ai";
-import { Type as Type7 } from "@dxos/echo";
-import { EchoClient } from "@dxos/echo-db";
-import { acquireReleaseResource } from "@dxos/effect";
-import { failedInvariant as failedInvariant2, invariant as invariant2 } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
-var wrapFunctionHandler = (func) => {
-  if (!FunctionDefinition.isFunction(func)) {
-    throw new TypeError("Invalid function definition");
-  }
-  return {
-    meta: {
-      key: func.key,
-      name: func.name,
-      description: func.description,
-      inputSchema: Type7.toJsonSchema(func.inputSchema),
-      outputSchema: func.outputSchema === void 0 ? void 0 : Type7.toJsonSchema(func.outputSchema),
-      services: func.services
-    },
-    handler: async ({ data, context }) => {
-      if ((func.services.includes(DatabaseService2.key) || func.services.includes(QueueService.key)) && (!context.services.dataService || !context.services.queryService)) {
-        throw new FunctionError({
-          message: "Services not provided: dataService, queryService"
-        });
-      }
-      try {
-        if (!SchemaAST2.isAnyKeyword(func.inputSchema.ast)) {
-          Schema10.validateSync(func.inputSchema)(data);
-        }
-        let result = await func.handler({
-          // TODO(dmaretskyi): Fix the types.
-          context,
-          data
-        });
-        if (Effect10.isEffect(result)) {
-          result = await Effect10.runPromise(result.pipe(Effect10.orDie, Effect10.provide(createServiceLayer(context))));
-        }
-        if (func.outputSchema && !SchemaAST2.isAnyKeyword(func.outputSchema.ast)) {
-          Schema10.validateSync(func.outputSchema)(result);
-        }
-        return result;
-      } catch (error) {
-        if (FunctionError.is(error)) {
-          throw error;
-        } else {
-          throw new FunctionError({
-            cause: error,
-            context: {
-              func: func.key
-            }
-          });
-        }
-      }
-    }
-  };
-};
-var createServiceLayer = (context) => {
-  return Layer5.unwrapScoped(Effect10.gen(function* () {
-    let client;
-    if (context.services.dataService && context.services.queryService) {
-      client = yield* acquireReleaseResource(() => {
-        invariant2(context.services.dataService && context.services.queryService, void 0, {
-          F: __dxlog_file2,
-          L: 99,
-          S: this,
-          A: [
-            "context.services.dataService && context.services.queryService",
-            ""
-          ]
-        });
-        return new EchoClient().connectToService({
-          dataService: context.services.dataService,
-          queryService: context.services.queryService,
-          queueService: context.services.queueService
-        });
-      });
-    }
-    const db = client && context.spaceId ? yield* acquireReleaseResource(() => client.constructDatabase({
-      spaceId: context.spaceId ?? failedInvariant2(),
-      spaceKey: PublicKey.fromHex(context.spaceKey ?? failedInvariant2("spaceKey missing in context")),
-      reactiveSchemaQuery: false
-    })) : void 0;
-    if (db) {
-      console.log("Setting space root", context.spaceRootUrl);
-      yield* Effect10.promise(() => db.setSpaceRoot(context.spaceRootUrl ?? failedInvariant2("spaceRootUrl missing in context")));
-    }
-    const queues = client && context.spaceId ? client.constructQueueFactory(context.spaceId) : void 0;
-    const dbLayer = db ? DatabaseService2.layer(db) : DatabaseService2.notAvailable;
-    const queuesLayer = queues ? QueueService.layer(queues) : QueueService.notAvailable;
-    const credentials = dbLayer ? CredentialsService.layerFromDatabase().pipe(Layer5.provide(dbLayer)) : CredentialsService.configuredLayer([]);
-    const functionInvocationService = MockedFunctionInvocationService;
-    const aiService = AiService.notAvailable;
-    const tracing = TracingService.layerNoop;
-    return Layer5.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiService, tracing);
-  }));
-};
-var MockedFunctionInvocationService = Layer5.succeed(FunctionInvocationService, {
-  invokeFunction: () => Effect10.die("Calling functions from functions is not implemented yet.")
-});
-export {
-  ComputeEvent,
-  ComputeEventLogger,
-  ComputeEventPayload,
-  ConfiguredCredentialsService,
-  ContextQueueService,
-  CredentialsService,
-  DatabaseService2 as DatabaseService,
-  Example,
-  FUNCTIONS_META_KEY,
-  FUNCTIONS_PRESET_META_KEY,
-  Function_exports as Function,
-  FunctionDefinition,
-  FunctionError,
-  FunctionInvocationService,
-  FunctionNotFoundError,
-  MESSAGE_PROPERTY_TOOL_CALL_ID,
-  QueueService,
-  Script_exports as Script,
-  ServiceNotAvailableError,
-  TracingService,
-  Trigger_exports as Trigger,
-  TriggerEvent_exports as TriggerEvent,
-  TriggerStateNotFoundError,
-  createDefectLogger,
-  createEventLogger,
-  defineFunction,
-  deserializeFunction,
-  getUserFunctionIdInMetadata,
-  logCustomEvent,
-  serializeFunction,
-  setUserFunctionIdInMetadata,
-  withAuthorization,
-  wrapFunctionHandler
-};
-//# sourceMappingURL=index.mjs.map