@dxos/functions 0.8.4-main.7ace549 → 0.8.4-main.8360d9e660

package/dist/lib/{browser → neutral}/index.mjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/errors.ts
 import { BaseError } from "@dxos/errors";
-var ServiceNotAvailableError = class extends BaseError.extend("SERVICE_NOT_AVAILABLE", "Service not available") {
+var ServiceNotAvailableError = class extends BaseError.extend("ServiceNotAvailable", "Service not available") {
   constructor(service, options) {
     super({
       context: {
@@ -16,7 +16,7 @@ var ServiceNotAvailableError = class extends BaseError.extend("SERVICE_NOT_AVAIL
     });
   }
 };
-var FunctionNotFoundError = class extends BaseError.extend("FUNCTION_NOT_FOUND", "Function not found") {
+var FunctionNotFoundError = class extends BaseError.extend("FunctionNotFound", "Function not found") {
   constructor(functionKey, options) {
     super({
       context: {
@@ -26,9 +26,9 @@ var FunctionNotFoundError = class extends BaseError.extend("FUNCTION_NOT_FOUND",
     });
   }
 };
-var FunctionError = class extends BaseError.extend("FUNCTION_ERROR", "Function invocation error") {
+var FunctionError = class extends BaseError.extend("FunctionError", "Function invocation error") {
 };
-var TriggerStateNotFoundError = class extends BaseError.extend("TRIGGER_STATE_NOT_FOUND", "Trigger state not found") {
+var TriggerStateNotFoundError = class extends BaseError.extend("TriggerStateNotFound", "Trigger state not found") {
 };
 
 // src/example/fib.ts
@@ -38,8 +38,9 @@ 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 { JsonSchema as JsonSchema2, Obj as Obj5 } from "@dxos/echo";
 import { assertArgument, failedInvariant } from "@dxos/invariant";
+import { Operation } from "@dxos/operation";
 
 // src/types/Function.ts
 var Function_exports = {};
@@ -49,7 +50,7 @@ __export(Function_exports, {
   setFrom: () => setFrom
 });
 import * as Schema2 from "effect/Schema";
-import { Annotation as Annotation2, JsonSchema, Obj as Obj2, Type as Type2 } from "@dxos/echo";
+import { Annotation as Annotation2, JsonSchema, Obj as Obj2, Ref as Ref2, Type as Type2 } from "@dxos/echo";
 import { SystemTypeAnnotation } from "@dxos/echo/internal";
 
 // src/types/Script.ts
@@ -68,13 +69,16 @@ var Script = Schema.Struct({
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
   changed: Schema.Boolean.pipe(FormInputAnnotation.set(false), Schema.optional),
-  source: Type.Ref(Text.Text).pipe(FormInputAnnotation.set(false))
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/Script",
+  source: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false))
+}).pipe(Type.object({
+  typename: "org.dxos.type.script",
   version: "0.1.0"
 }), Annotation.LabelAnnotation.set([
   "name"
-]));
+]), Annotation.IconAnnotation.set({
+  icon: "ph--code--regular",
+  hue: "sky"
+}));
 var make = ({ source = "", ...props } = {}) => Obj.make(Script, {
   ...props,
   source: Ref.make(Text.make(source))
@@ -101,7 +105,7 @@ var Function = Schema2.Struct({
   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(Type2.Ref(Script)),
+  source: Schema2.optional(Ref2.Ref(Script)),
   inputSchema: Schema2.optional(JsonSchema.JsonSchema),
   outputSchema: Schema2.optional(JsonSchema.JsonSchema),
   /**
@@ -111,22 +115,27 @@ var Function = Schema2.Struct({
   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",
+}).pipe(Type2.object({
+  typename: "org.dxos.type.function",
   version: "0.1.0"
 }), Annotation2.LabelAnnotation.set([
   "name"
-]), SystemTypeAnnotation.set(true));
+]), Annotation2.IconAnnotation.set({
+  icon: "ph--function--regular",
+  hue: "blue"
+}), SystemTypeAnnotation.set(true));
 var make2 = (props) => Obj2.make(Function, props);
 var setFrom = (target, source) => {
-  target.key = source.key ?? target.key;
-  target.name = source.name ?? target.name;
-  target.version = source.version;
-  target.description = source.description;
-  target.updated = source.updated;
-  target.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : void 0;
-  target.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : void 0;
-  Obj2.getMeta(target).keys = JSON.parse(JSON.stringify(Obj2.getMeta(source).keys));
+  Obj2.change(target, (t) => {
+    t.key = source.key ?? target.key;
+    t.name = source.name ?? target.name;
+    t.version = source.version;
+    t.description = source.description;
+    t.updated = source.updated;
+    t.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : void 0;
+    t.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : void 0;
+    Obj2.getMeta(t).keys = JSON.parse(JSON.stringify(Obj2.getMeta(source).keys));
+  });
 };
 
 // src/types/Trigger.ts
@@ -144,9 +153,10 @@ __export(Trigger_exports, {
 });
 import * as Schema3 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
-import { Obj as Obj3, QueryAST, Type as Type3 } from "@dxos/echo";
+import { Annotation as Annotation3, Obj as Obj3, QueryAST, Ref as Ref3, Type as Type3 } from "@dxos/echo";
 import { OptionsAnnotationId, SystemTypeAnnotation as SystemTypeAnnotation2 } from "@dxos/echo/internal";
 import { DXN } from "@dxos/keys";
+import { Expando } from "@dxos/schema";
 var Kinds = [
   "email",
   "queue",
@@ -159,12 +169,12 @@ var kindLiteralAnnotations = {
 };
 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({
@@ -172,7 +182,7 @@ var SubscriptionSpec = Schema3.Struct({
       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({
@@ -185,7 +195,7 @@ var SubscriptionSpec = Schema3.Struct({
   }).annotations({
     title: "Options"
   }))
-}).pipe(Schema3.mutable);
+});
 var TimerSpec = Schema3.Struct({
   kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
   cron: Schema3.String.annotations({
@@ -194,7 +204,7 @@ var TimerSpec = Schema3.Struct({
       "0 0 * * *"
     ]
   })
-}).pipe(Schema3.mutable);
+});
 var WebhookSpec = Schema3.Struct({
   kind: Schema3.Literal("webhook").annotations(kindLiteralAnnotations),
   method: Schema3.optional(Schema3.String.annotations({
@@ -207,16 +217,16 @@ var WebhookSpec = Schema3.Struct({
   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({
+var TriggerSchema = Schema3.Struct({
   /**
   * Function or workflow to invoke.
   */
   // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema3.optional(Type3.Ref(Type3.Expando).annotations({
+  function: Schema3.optional(Ref3.Ref(Expando.Expando).annotations({
     title: "Function"
   })),
   /**
@@ -227,30 +237,40 @@ var Trigger_ = Schema3.Struct({
   inputNodeId: Schema3.optional(Schema3.String.annotations({
     title: "Input Node ID"
   })),
+  // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
+  //  Need lint rule; or agent rule to require PR review for "boolean" key word.
   enabled: Schema3.optional(Schema3.Boolean.annotations({
     title: "Enabled"
   })),
   spec: Schema3.optional(Spec),
+  concurrency: Schema3.optional(Schema3.Number.annotations({
+    title: "Concurrency",
+    default: 1,
+    description: "Maximum number of concurrent invocations of the trigger. For queue triggers, this will process queue items in parallel."
+  })),
   /**
   * Passed as the input data to the function.
   * Must match the function's input schema.
   *
   * @example
   * {
-  *   item: '{{$.trigger.event}}',
+  *   item: '{{event.item}}',
   *   instructions: 'Summarize and perform entity-extraction'
   *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
   * }
   */
-  input: Schema3.optional(Schema3.mutable(Schema3.Record({
+  input: Schema3.optional(Schema3.Record({
     key: Schema3.String,
     value: Schema3.Any
-  })))
-}).pipe(Type3.Obj({
-  typename: "dxos.org/type/Trigger",
+  }))
+}).pipe(Type3.object({
+  typename: "org.dxos.type.trigger",
   version: "0.1.0"
+}), Annotation3.IconAnnotation.set({
+  icon: "ph--lightning--regular",
+  hue: "yellow"
 }), SystemTypeAnnotation2.set(true));
-var Trigger = Trigger_;
+var Trigger = TriggerSchema;
 var make3 = (props) => Obj3.make(Trigger, props);
 
 // src/types/TriggerEvent.ts
@@ -260,22 +280,23 @@ __export(TriggerEvent_exports, {
   QueueEvent: () => QueueEvent,
   SubscriptionEvent: () => SubscriptionEvent,
   TimerEvent: () => TimerEvent,
+  TriggerEvent: () => TriggerEvent,
   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({
+import { DXN as DXN2, Obj as Obj4, Ref as Ref4 } from "@dxos/echo";
+var EmailEvent = Schema4.Struct({
   from: Schema4.String,
   to: Schema4.String,
   subject: Schema4.String,
   created: Schema4.String,
   body: Schema4.String
-}));
-var QueueEvent = Schema4.mutable(Schema4.Struct({
+});
+var QueueEvent = Schema4.Struct({
   queue: DXN2.Schema,
   item: Schema4.Any,
   cursor: Schema4.String
-}));
+});
 var SubscriptionEvent = Schema4.Struct({
   /**
   * Type of the mutation.
@@ -285,16 +306,16 @@ var SubscriptionEvent = Schema4.Struct({
   /**
   * Reference to the object that was changed or created.
   */
-  subject: Type4.Ref(Obj4.Any),
+  subject: Ref4.Ref(Obj4.Unknown),
   /**
   * @deprecated
   */
   changedObjectId: Schema4.optional(Schema4.String)
-}).pipe(Schema4.mutable);
-var TimerEvent = Schema4.mutable(Schema4.Struct({
+});
+var TimerEvent = Schema4.Struct({
   tick: Schema4.Number
-}));
-var WebhookEvent = Schema4.mutable(Schema4.Struct({
+});
+var WebhookEvent = Schema4.Struct({
   url: Schema4.String,
   method: Schema4.Literal("GET", "POST"),
   headers: Schema4.Record({
@@ -302,11 +323,12 @@ var WebhookEvent = Schema4.mutable(Schema4.Struct({
     value: Schema4.String
   }),
   bodyText: Schema4.String
-}));
+});
+var TriggerEvent = Schema4.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
 
 // src/types/url.ts
-var FUNCTIONS_META_KEY = "dxos.org/service/function";
-var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
+var FUNCTIONS_META_KEY = "org.dxos.service.function";
+var FUNCTIONS_PRESET_META_KEY = "org.dxos.service.function-preset";
 var getUserFunctionIdInMetadata = (meta) => {
   return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
 };
@@ -325,7 +347,7 @@ var setUserFunctionIdInMetadata = (meta, functionId) => {
 };
 
 // src/sdk.ts
-var typeId = Symbol.for("@dxos/functions/FunctionDefinition");
+var typeId = /* @__PURE__ */ Symbol.for("@dxos/functions/FunctionDefinition");
 var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler, types, services }) => {
   if (!Schema5.isSchema(inputSchema)) {
     throw new Error("Input schema must be a valid schema");
@@ -376,14 +398,43 @@ var getServiceKeys = (services) => {
     if (typeof tag.key === "string") {
       return tag.key;
     }
-    console.log(tag);
     failedInvariant();
   });
 };
+var toOperation = (functionDef) => {
+  const op = Operation.make({
+    schema: {
+      input: functionDef.inputSchema,
+      output: functionDef.outputSchema ?? Schema5.Any
+    },
+    meta: {
+      key: functionDef.key,
+      name: functionDef.name,
+      description: functionDef.description
+    }
+  });
+  const operationHandler = (input) => {
+    const result = functionDef.handler({
+      context: {},
+      data: input
+    });
+    if (Effect.isEffect(result)) {
+      return result;
+    }
+    if (result instanceof Promise) {
+      return Effect.tryPromise(() => result);
+    }
+    return Effect.succeed(result);
+  };
+  return {
+    ...op,
+    handler: operationHandler
+  };
+};
 var FunctionDefinition = {
   make: defineFunction,
   isFunction: (value2) => {
-    return typeof value2 === "object" && value2 !== null && Symbol.for("@dxos/functions/FunctionDefinition") in value2;
+    return typeof value2 === "object" && value2 !== null && /* @__PURE__ */ Symbol.for("@dxos/functions/FunctionDefinition") in value2;
   },
   serialize: (functionDef) => {
     assertArgument(FunctionDefinition.isFunction(functionDef), "functionDef");
@@ -392,7 +443,8 @@ var FunctionDefinition = {
   deserialize: (functionObj) => {
     assertArgument(Obj5.instanceOf(Function_exports.Function, functionObj), "functionObj");
     return deserializeFunction(functionObj);
-  }
+  },
+  toOperation
 };
 var serializeFunction = (functionDef) => {
   const fn4 = Function_exports.make({
@@ -400,12 +452,12 @@ var serializeFunction = (functionDef) => {
     name: functionDef.name,
     version: "0.1.0",
     description: functionDef.description,
-    inputSchema: Type5.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? void 0 : Type5.toJsonSchema(functionDef.outputSchema),
+    inputSchema: JsonSchema2.toJsonSchema(functionDef.inputSchema),
+    outputSchema: !functionDef.outputSchema ? void 0 : JsonSchema2.toJsonSchema(functionDef.outputSchema),
     services: functionDef.services
   });
   if (functionDef.meta?.deployedFunctionId) {
-    setUserFunctionIdInMetadata(Obj5.getMeta(fn4), functionDef.meta.deployedFunctionId);
+    Obj5.change(fn4, (fn5) => setUserFunctionIdInMetadata(Obj5.getMeta(fn5), functionDef.meta.deployedFunctionId));
   }
   return fn4;
 };
@@ -416,8 +468,8 @@ var deserializeFunction = (functionObj) => {
     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),
+    inputSchema: !functionObj.inputSchema ? Schema5.Unknown : JsonSchema2.toEffectSchema(functionObj.inputSchema),
+    outputSchema: !functionObj.outputSchema ? void 0 : JsonSchema2.toEffectSchema(functionObj.outputSchema),
     // TODO(dmaretskyi): This should throw error.
     handler: () => {
     },
@@ -494,15 +546,11 @@ var sleep_default = defineFunction({
 });
 
 // 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";
+var ExampleFunctions = {
+  Fibonacci: fib_default,
+  Reply: reply_default,
+  Sleep: sleep_default
+};
 
 // src/services/credentials.ts
 import * as HttpClient from "@effect/platform/HttpClient";
@@ -512,7 +560,7 @@ 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 { Database } from "@dxos/echo";
 import { AccessToken } from "@dxos/types";
 var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/functions/CredentialsService")() {
   static getCredential = (query) => Effect5.gen(function* () {
@@ -536,14 +584,23 @@ var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/fu
     }));
     return new ConfiguredCredentialsService(serviceCredentials);
   }));
-  static layerFromDatabase = () => Layer.effect(_CredentialsService, Effect5.gen(function* () {
-    const dbService = yield* DatabaseService;
+  static layerFromDatabase = ({ caching = false } = {}) => Layer.effect(_CredentialsService, Effect5.gen(function* () {
+    const dbService = yield* Database.Service;
+    const cache = /* @__PURE__ */ new Map();
     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) => ({
+      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) => {
@@ -579,18 +636,17 @@ var ConfiguredCredentialsService = class {
     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;
+var withAuthorization = (token, kind) => HttpClient.mapRequest((request) => {
+  const authorization = kind ? `${kind} ${token}` : token;
   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 { Obj as Obj7, Type as Type4 } from "@dxos/echo";
 import { invariant } from "@dxos/invariant";
 import { LogLevel, log as log2 } from "@dxos/log";
 
@@ -600,12 +656,19 @@ 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 { ObjectId } from "@dxos/keys";
 import { Message } from "@dxos/types";
 var TracingService = class _TracingService extends Context2.Tag("@dxos/functions/TracingService")() {
   static noop = {
     getTraceContext: () => ({}),
     write: () => {
-    }
+    },
+    traceInvocationStart: () => Effect6.sync(() => ({
+      invocationId: ObjectId.random(),
+      invocationTraceQueue: void 0
+    })),
+    traceInvocationEnd: () => Effect6.sync(() => {
+    })
   };
   static layerNoop = Layer2.succeed(_TracingService, _TracingService.noop);
   /**
@@ -615,11 +678,22 @@ var TracingService = class _TracingService extends Context2.Tag("@dxos/functions
     const tracing = yield* _TracingService;
     const context = mapContext(tracing.getTraceContext());
     return {
-      write: (event) => tracing.write(event),
-      getTraceContext: () => context
+      write: (event, context2) => tracing.write(event, context2),
+      getTraceContext: () => context,
+      traceInvocationStart: () => Effect6.die("Tracing invocation inside another invocation is not supported."),
+      traceInvocationEnd: () => Effect6.die("Tracing invocation inside another invocation is not supported.")
     };
   }));
   /**
+  * Create sublayer to trace an invocation.
+  * @param data
+  * @returns
+  */
+  static layerInvocation = (data) => _TracingService.layerSubframe((context) => ({
+    ...context,
+    currentInvocation: data
+  }));
+  /**
   * Emit the current human-readable execution status.
   */
   static emitStatus = Effect6.fnUntraced(function* (data) {
@@ -629,7 +703,7 @@ var TracingService = class _TracingService extends Context2.Tag("@dxos/functions
       toolCallId: tracing.getTraceContext().toolCallId,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       ...data
-    }));
+    }), tracing.getTraceContext());
   });
   static emitConverationMessage = Effect6.fnUntraced(function* (data) {
     const tracing = yield* _TracingService;
@@ -640,7 +714,7 @@ var TracingService = class _TracingService extends Context2.Tag("@dxos/functions
         [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
         ...data.properties
       }
-    }));
+    }), tracing.getTraceContext());
   });
 };
 var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
@@ -678,8 +752,8 @@ var ComputeEventPayload = Schema9.Union(Schema9.Struct({
 }));
 var ComputeEvent = Schema9.Struct({
   payload: ComputeEventPayload
-}).pipe(Type6.Obj({
-  typename: "dxos.org/type/ComputeEvent",
+}).pipe(Type4.object({
+  typename: "org.dxos.type.compute-event",
   version: "0.1.0"
 }));
 var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/functions/ComputeEventLogger")() {
@@ -697,7 +771,7 @@ var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/f
       log: (event) => {
         tracing.write(Obj7.make(ComputeEvent, {
           payload: event
-        }));
+        }), tracing.getTraceContext());
       },
       nodeId: void 0
     };
@@ -753,16 +827,22 @@ var createEventLogger = (level, message = "event") => {
 // src/services/function-invocation-service.ts
 import * as Context4 from "effect/Context";
 import * as Effect8 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
 var FunctionInvocationService = class _FunctionInvocationService extends Context4.Tag("@dxos/functions/FunctionInvocationService")() {
+  static layerNotAvailable = Layer4.succeed(_FunctionInvocationService, {
+    invokeFunction: () => Effect8.die("FunctionInvocationService is not avaialble."),
+    resolveFunction: () => Effect8.die("FunctionInvocationService is not available.")
+  });
   static invokeFunction = (functionDef, input) => Effect8.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+  static resolveFunction = (key) => Effect8.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key);
 };
 
 // src/services/queues.ts
 import * as Context5 from "effect/Context";
 import * as Effect9 from "effect/Effect";
-import * as Layer4 from "effect/Layer";
+import * as Layer5 from "effect/Layer";
 var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/QueueService")() {
-  static notAvailable = Layer4.succeed(_QueueService, {
+  static notAvailable = Layer5.succeed(_QueueService, {
     queues: {
       get(_dxn) {
         throw new Error("Queues not available");
@@ -779,7 +859,7 @@ var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/Que
       queue
     };
   };
-  static layer = (queues, queue) => Layer4.succeed(_QueueService, _QueueService.make(queues, queue));
+  static layer = (queues, queue) => Layer5.succeed(_QueueService, _QueueService.make(queues, queue));
   /**
   * Gets a queue by its DXN.
   */
@@ -791,22 +871,83 @@ var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/Que
   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, {
+  static layer = (queue) => Layer5.succeed(_ContextQueueService, {
     queue
   });
 };
 
 // src/protocol/protocol.ts
-import * as Effect10 from "effect/Effect";
-import * as Layer5 from "effect/Layer";
+import * as AnthropicClient from "@effect/ai-anthropic/AnthropicClient";
+import * as Effect11 from "effect/Effect";
+import * as Layer7 from "effect/Layer";
 import * as Schema10 from "effect/Schema";
 import * as SchemaAST2 from "effect/SchemaAST";
-import { AiService } from "@dxos/ai";
+import { AiModelResolver, AiService } from "@dxos/ai";
+import { AnthropicResolver } from "@dxos/ai/resolvers";
 import { LifecycleState, Resource } from "@dxos/context";
-import { Type as Type7 } from "@dxos/echo";
-import { EchoClient } from "@dxos/echo-db";
+import { Database as Database2, Feed, JsonSchema as JsonSchema3, Ref as Ref5 } from "@dxos/echo";
+import { refFromEncodedReference } from "@dxos/echo/internal";
+import { EchoClient, createFeedServiceLayer } from "@dxos/echo-db";
+import { runAndForwardErrors } from "@dxos/effect";
 import { assertState, failedInvariant as failedInvariant2, invariant as invariant2 } from "@dxos/invariant";
 import { PublicKey } from "@dxos/keys";
+
+// src/protocol/functions-ai-http-client.ts
+import * as Headers from "@effect/platform/Headers";
+import * as HttpClient2 from "@effect/platform/HttpClient";
+import * as HttpClientError from "@effect/platform/HttpClientError";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect10 from "effect/Effect";
+import * as FiberRef from "effect/FiberRef";
+import * as Layer6 from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { log as log3 } from "@dxos/log";
+import { ErrorCodec } from "@dxos/protocols";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/protocol/functions-ai-http-client.ts";
+var requestInitTagKey = "@effect/platform/FetchHttpClient/FetchOptions";
+var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
+  static make = (service) => HttpClient2.make((request, url, signal, fiber) => {
+    const context = fiber.getFiberRef(FiberRef.currentContext);
+    const options = context.unsafeMap.get(requestInitTagKey) ?? {};
+    const headers = options.headers ? Headers.merge(Headers.fromInput(options.headers), request.headers) : request.headers;
+    const send = (body) => Effect10.tryPromise({
+      try: () => service.fetch(new Request(url, {
+        ...options,
+        method: request.method,
+        headers,
+        body
+      })),
+      catch: (cause) => {
+        log3.error("Failed to fetch", {
+          errorSerialized: ErrorCodec.encode(cause)
+        }, {
+          F: __dxlog_file2,
+          L: 43,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return new HttpClientError.RequestError({
+          request,
+          reason: "Transport",
+          cause
+        });
+      }
+    }).pipe(Effect10.map((response) => HttpClientResponse.fromWeb(request, response)));
+    switch (request.body._tag) {
+      case "Raw":
+      case "Uint8Array":
+        return send(request.body.body);
+      case "FormData":
+        return send(request.body.formData);
+      case "Stream":
+        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect10.flatMap(send));
+    }
+    return send(void 0);
+  });
+  static layer = (service) => Layer6.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
+};
+
+// src/protocol/protocol.ts
 function _ts_add_disposable_resource(env, value2, async) {
   if (value2 !== null && value2 !== void 0) {
     if (typeof value2 !== "object" && typeof value2 !== "function") throw new TypeError("Object expected.");
@@ -872,7 +1013,7 @@ function _ts_dispose_resources(env) {
     return next();
   })(env);
 }
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
 var wrapFunctionHandler = (func) => {
   if (!FunctionDefinition.isFunction(func)) {
     throw new TypeError("Invalid function definition");
@@ -882,12 +1023,12 @@ var wrapFunctionHandler = (func) => {
       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),
+      inputSchema: JsonSchema3.toJsonSchema(func.inputSchema),
+      outputSchema: func.outputSchema === void 0 ? void 0 : JsonSchema3.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)) {
+      if ((func.services.includes(Database2.Service.key) || func.services.includes(QueueService.key) || func.services.includes(Feed.Service.key)) && (!context.services.dataService || !context.services.queryService)) {
         throw new FunctionError({
           message: "Services not provided: dataService, queryService"
         });
@@ -912,23 +1053,24 @@ var wrapFunctionHandler = (func) => {
           const funcContext = _ts_add_disposable_resource(env, await new FunctionContext(context).open(), true);
           if (func.types.length > 0) {
             invariant2(funcContext.db, "Database is required for functions with types", {
-              F: __dxlog_file2,
-              L: 63,
+              F: __dxlog_file3,
+              L: 70,
               S: void 0,
               A: [
                 "funcContext.db",
                 "'Database is required for functions with types'"
               ]
             });
-            funcContext.db.graph.schemaRegistry.addSchema(func.types);
+            await funcContext.db.graph.schemaRegistry.register(func.types);
           }
+          const dataWithDecodedRefs = funcContext.db && !SchemaAST2.isAnyKeyword(func.inputSchema.ast) ? decodeRefsFromSchema(func.inputSchema.ast, data, funcContext.db) : data;
           let result = await func.handler({
             // TODO(dmaretskyi): Fix the types.
             context,
-            data
+            data: dataWithDecodedRefs
           });
-          if (Effect10.isEffect(result)) {
-            result = await Effect10.runPromise(result.pipe(Effect10.orDie, Effect10.provide(funcContext.createLayer())));
+          if (Effect11.isEffect(result)) {
+            result = await runAndForwardErrors(result.pipe(Effect11.orDie, Effect11.provide(funcContext.createLayer())));
           }
           if (func.outputSchema && !SchemaAST2.isAnyKeyword(func.outputSchema.ast)) {
             Schema10.validateSync(func.outputSchema)(result);
@@ -968,7 +1110,8 @@ var FunctionContext = class extends Resource {
     this.db = this.client && this.context.spaceId ? this.client.constructDatabase({
       spaceId: this.context.spaceId ?? failedInvariant2(),
       spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant2("spaceKey missing in context")),
-      reactiveSchemaQuery: false
+      reactiveSchemaQuery: false,
+      preloadSchemaOnOpen: false
     }) : void 0;
     await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant2("spaceRootUrl missing in context"));
     await this.db?.open();
@@ -980,18 +1123,88 @@ var FunctionContext = class extends Resource {
   }
   createLayer() {
     assertState(this._lifecycleState === LifecycleState.OPEN, "FunctionContext is not open");
-    const dbLayer = this.db ? DatabaseService2.layer(this.db) : DatabaseService2.notAvailable;
+    const dbLayer = this.db ? Database2.layer(this.db) : Database2.notAvailable;
     const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
-    const credentials = dbLayer ? CredentialsService.layerFromDatabase().pipe(Layer5.provide(dbLayer)) : CredentialsService.configuredLayer([]);
+    const feedLayer = this.queues ? createFeedServiceLayer(this.queues) : Feed.notAvailable;
+    const credentials = dbLayer ? CredentialsService.layerFromDatabase({
+      caching: true
+    }).pipe(Layer7.provide(dbLayer)) : CredentialsService.configuredLayer([]);
     const functionInvocationService = MockedFunctionInvocationService;
-    const aiService = AiService.notAvailable;
     const tracing = TracingService.layerNoop;
-    return Layer5.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiService, tracing);
+    const aiLayer = this.context.services.functionsAiService ? AiModelResolver.AiModelResolver.buildAiService.pipe(Layer7.provide(AnthropicResolver.make().pipe(Layer7.provide(AnthropicClient.layer({
+      // Note: It doesn't matter what is base url here, it will be proxied to ai gateway in edge.
+      apiUrl: "http://internal/provider/anthropic"
+    }).pipe(Layer7.provide(FunctionsAiHttpClient.layer(this.context.services.functionsAiService))))))) : AiService.notAvailable;
+    return Layer7.mergeAll(dbLayer, queuesLayer, feedLayer, credentials, functionInvocationService, aiLayer, tracing);
   }
 };
-var MockedFunctionInvocationService = Layer5.succeed(FunctionInvocationService, {
-  invokeFunction: () => Effect10.die("Calling functions from functions is not implemented yet.")
+var MockedFunctionInvocationService = Layer7.succeed(FunctionInvocationService, {
+  invokeFunction: () => Effect11.die("Calling functions from functions is not implemented yet."),
+  resolveFunction: () => Effect11.die("Not implemented.")
 });
+var decodeRefsFromSchema = (ast, value2, db) => {
+  if (value2 == null) {
+    return value2;
+  }
+  const encoded = SchemaAST2.encodedBoundAST(ast);
+  if (Ref5.isRefType(encoded)) {
+    if (Ref5.isRef(value2)) {
+      return value2;
+    }
+    if (typeof value2 === "object" && value2 !== null && typeof value2["/"] === "string") {
+      const resolver = db.graph.createRefResolver({
+        context: {
+          space: db.spaceId
+        }
+      });
+      return refFromEncodedReference(value2, resolver);
+    }
+    return value2;
+  }
+  switch (encoded._tag) {
+    case "TypeLiteral": {
+      if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) {
+        return value2;
+      }
+      const result = {
+        ...value2
+      };
+      for (const prop of SchemaAST2.getPropertySignatures(encoded)) {
+        const key = prop.name.toString();
+        if (key in result) {
+          result[key] = decodeRefsFromSchema(prop.type, result[key], db);
+        }
+      }
+      return result;
+    }
+    case "TupleType": {
+      if (!Array.isArray(value2)) {
+        return value2;
+      }
+      if (encoded.elements.length === 0 && encoded.rest.length === 1) {
+        const elementType = encoded.rest[0].type;
+        return value2.map((item) => decodeRefsFromSchema(elementType, item, db));
+      }
+      return value2;
+    }
+    case "Union": {
+      const nonUndefined = encoded.types.filter((t) => !SchemaAST2.isUndefinedKeyword(t));
+      if (nonUndefined.length === 1) {
+        return decodeRefsFromSchema(nonUndefined[0], value2, db);
+      }
+      return value2;
+    }
+    case "Suspend": {
+      return decodeRefsFromSchema(encoded.f(), value2, db);
+    }
+    case "Refinement": {
+      return decodeRefsFromSchema(encoded.from, value2, db);
+    }
+    default: {
+      return value2;
+    }
+  }
+};
 export {
   ComputeEvent,
   ComputeEventLogger,
@@ -999,8 +1212,7 @@ export {
   ConfiguredCredentialsService,
   ContextQueueService,
   CredentialsService,
-  DatabaseService2 as DatabaseService,
-  Example,
+  ExampleFunctions,
   FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
   Function_exports as Function,
@@ -1024,6 +1236,7 @@ export {
   logCustomEvent,
   serializeFunction,
   setUserFunctionIdInMetadata,
+  toOperation,
   withAuthorization,
   wrapFunctionHandler
 };