@dxos/functions 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/dist/lib/neutral/index.mjs

@@ -1,621 +1,12 @@
-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("ServiceNotAvailable", "Service not available") {
-  constructor(service, options) {
-    super({
-      context: {
-        service
-      },
-      ...options
-    });
-  }
-};
-var FunctionNotFoundError = class extends BaseError.extend("FunctionNotFound", "Function not found") {
-  constructor(functionKey, options) {
-    super({
-      context: {
-        function: functionKey
-      },
-      ...options
-    });
-  }
-};
-var FunctionError = class extends BaseError.extend("FunctionError", "Function invocation error") {
-};
-var TriggerStateNotFoundError = class extends BaseError.extend("TriggerStateNotFound", "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 { 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 = {};
-__export(Function_exports, {
-  Function: () => Function,
-  make: () => make2,
-  setFrom: () => setFrom
-});
-import * as Schema2 from "effect/Schema";
-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
-var Script_exports = {};
-__export(Script_exports, {
-  Script: () => Script,
-  make: () => make
-});
-import * as Schema from "effect/Schema";
-import { Annotation, Obj, Ref, Type } from "@dxos/echo";
-import { FormInputAnnotation } 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(FormInputAnnotation.set(false), Schema.optional),
-  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))
-});
-
-// 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"
-  }),
-  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.Ref(Script)),
-  inputSchema: Schema2.optional(JsonSchema.JsonSchema),
-  outputSchema: Schema2.optional(JsonSchema.JsonSchema),
-  /**
-  * 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.object({
-  typename: "org.dxos.type.function",
-  version: "0.1.0"
-}), Annotation2.LabelAnnotation.set([
-  "name"
-]), Annotation2.IconAnnotation.set({
-  icon: "ph--function--regular",
-  hue: "blue"
-}), SystemTypeAnnotation.set(true));
-var make2 = (props) => Obj2.make(Function, props);
-var setFrom = (target, source) => {
-  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
-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 { 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",
-  "subscription",
-  "timer",
-  "webhook"
-];
-var kindLiteralAnnotations = {
-  title: "Kind"
-};
-var EmailSpec = Schema3.Struct({
-  kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
-});
-var QueueSpec = Schema3.Struct({
-  kind: Schema3.Literal("queue").annotations(kindLiteralAnnotations),
-  // TODO(dmaretskyi): Change to a reference.
-  queue: DXN.Schema
-});
-var SubscriptionSpec = Schema3.Struct({
-  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
-  query: Schema3.Struct({
-    raw: Schema3.optional(Schema3.String.annotations({
-      title: "Query"
-    })),
-    ast: QueryAST.Query
-  }),
-  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"
-  }))
-});
-var TimerSpec = Schema3.Struct({
-  kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema3.String.annotations({
-    title: "Cron",
-    [SchemaAST.ExamplesAnnotationId]: [
-      "0 0 * * *"
-    ]
-  })
-});
-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"
-  }))
-});
-var Spec = Schema3.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
-  title: "Trigger"
-});
-var TriggerSchema = Schema3.Struct({
-  /**
-  * Function or workflow to invoke.
-  */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema3.optional(Ref3.Ref(Expando.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"
-  })),
-  // 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: '{{event.item}}',
-  *   instructions: 'Summarize and perform entity-extraction'
-  *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
-  * }
-  */
-  input: Schema3.optional(Schema3.Record({
-    key: Schema3.String,
-    value: Schema3.Any
-  }))
-}).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 = TriggerSchema;
-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,
-  TriggerEvent: () => TriggerEvent,
-  WebhookEvent: () => WebhookEvent
-});
-import * as Schema4 from "effect/Schema";
-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.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: Ref4.Ref(Obj4.Unknown),
-  /**
-  * @deprecated
-  */
-  changedObjectId: Schema4.optional(Schema4.String)
-});
-var TimerEvent = Schema4.Struct({
-  tick: Schema4.Number
-});
-var WebhookEvent = Schema4.Struct({
-  url: Schema4.String,
-  method: Schema4.Literal("GET", "POST"),
-  headers: Schema4.Record({
-    key: Schema4.String,
-    value: Schema4.String
-  }),
-  bodyText: Schema4.String
-});
-var TriggerEvent = Schema4.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
-
-// src/types/url.ts
-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;
-};
-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 = /* @__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");
-  }
-  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,
-    types: types ?? [],
-    services: !services ? [] : getServiceKeys(services)
-  };
-};
-var getServiceKeys = (services) => {
-  return services.map((tag) => {
-    if (typeof tag.key === "string") {
-      return tag.key;
-    }
-    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 && /* @__PURE__ */ 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);
-  },
-  toOperation
-};
-var serializeFunction = (functionDef) => {
-  const fn4 = Function_exports.make({
-    key: functionDef.key,
-    name: functionDef.name,
-    version: "0.1.0",
-    description: functionDef.description,
-    inputSchema: JsonSchema2.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? void 0 : JsonSchema2.toJsonSchema(functionDef.outputSchema),
-    services: functionDef.services
-  });
-  if (functionDef.meta?.deployedFunctionId) {
-    Obj5.change(fn4, (fn5) => setUserFunctionIdInMetadata(Obj5.getMeta(fn5), 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 : JsonSchema2.toEffectSchema(functionObj.inputSchema),
-    outputSchema: !functionObj.outputSchema ? void 0 : JsonSchema2.toEffectSchema(functionObj.outputSchema),
-    // TODO(dmaretskyi): This should throw error.
-    handler: () => {
-    },
-    services: functionObj.services ?? [],
-    types: [],
-    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
-var ExampleFunctions = {
-  Fibonacci: fib_default,
-  Reply: reply_default,
-  Sleep: sleep_default
-};
-
 // 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 Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
-import { Query } from "@dxos/echo";
-import { Database } from "@dxos/echo";
+import { Credential } from "@dxos/compute";
+import { Database, Query } from "@dxos/echo";
 import { AccessToken } from "@dxos/types";
-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 = ({ caching = false } = {}) => Layer.effect(_CredentialsService, Effect5.gen(function* () {
-    const dbService = yield* Database.Service;
-    const cache = /* @__PURE__ */ new Map();
-    const queryCredentials = async (query) => {
-      const cacheKey = JSON.stringify(query);
-      if (caching && cache.has(cacheKey)) {
-        return cache.get(cacheKey);
-      }
-      const accessTokens = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
-      const credentials = accessTokens.filter((accessToken) => accessToken.source === query.service).map((accessToken) => ({
-        service: accessToken.source,
-        apiKey: accessToken.token
-      }));
-      if (caching) {
-        cache.set(cacheKey, credentials);
-      }
-      return credentials;
-    };
-    return {
-      getCredential: async (query) => {
-        const credentials = await queryCredentials(query);
-        if (credentials.length === 0) {
-          throw new Error(`Credential not found for service: ${query.service}`);
-        }
-        return credentials[0];
-      },
-      queryCredentials: async (query) => {
-        return queryCredentials(query);
-      }
-    };
-  }));
-};
 var ConfiguredCredentialsService = class {
   credentials;
   constructor(credentials = []) {
@@ -640,277 +31,127 @@ 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 Type4 } 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 { 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);
-  /**
-  * 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());
+var configuredCredentialsLayer = (credentials) => Layer.succeed(Credential.CredentialsService, new ConfiguredCredentialsService(credentials));
+var credentialsLayerConfig = (credentials) => Layer.effect(Credential.CredentialsService, Effect.gen(function* () {
+  const serviceCredentials = yield* Effect.forEach(credentials, ({ service, apiKey }) => Effect.gen(function* () {
     return {
-      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.")
+      service,
+      apiKey: Redacted.value(yield* apiKey)
     };
   }));
-  /**
-  * 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) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj6.make(AgentStatus, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      toolCallId: tracing.getTraceContext().toolCallId,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      ...data
-    }), tracing.getTraceContext());
-  });
-  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
-      }
-    }), tracing.getTraceContext());
-  });
-};
-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(Type4.object({
-  typename: "org.dxos.type.compute-event",
-  version: "0.1.0"
+  return new ConfiguredCredentialsService(serviceCredentials);
 }));
-var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/functions/ComputeEventLogger")() {
-  static noop = {
-    log: () => {
-    },
-    nodeId: void 0
+var credentialsLayerFromDatabase = ({ caching = false } = {}) => Layer.effect(Credential.CredentialsService, Effect.gen(function* () {
+  const dbService = yield* Database.Service;
+  const cache = /* @__PURE__ */ new Map();
+  const queryCredentials = async (query) => {
+    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;
   };
-  /**
-  * 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
-        }), tracing.getTraceContext());
-      },
-      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);
+    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];
     },
-    nodeId: void 0
+    queryCredentials: async (query) => {
+      return queryCredentials(query);
+    }
   };
-};
+}));
 
 // 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.")
+import * as Context from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+var FunctionInvocationService = class _FunctionInvocationService extends Context.Tag("@dxos/functions/FunctionInvocationService")() {
+  static layerNotAvailable = Layer2.succeed(_FunctionInvocationService, {
+    invokeFunction: () => Effect2.die("FunctionInvocationService is not avaialble."),
+    resolveFunction: () => Effect2.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);
+  static invokeFunction = (functionDef, input) => Effect2.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+  static resolveFunction = (key) => Effect2.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key);
 };
 
 // src/services/queues.ts
-import * as Context5 from "effect/Context";
-import * as Effect9 from "effect/Effect";
-import * as Layer5 from "effect/Layer";
-var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/QueueService")() {
-  static notAvailable = Layer5.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) => Layer5.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));
+import { QueueService, feedServiceFromQueueServiceLayer } from "@dxos/echo-db";
+
+// src/services/tracing.ts
+var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
+
+// src/types/url.ts
+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;
 };
-var ContextQueueService = class _ContextQueueService extends Context5.Tag("@dxos/functions/ContextQueueService")() {
-  static layer = (queue) => Layer5.succeed(_ContextQueueService, {
-    queue
-  });
+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/protocol/protocol.ts
 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 { AiModelResolver, AiService } from "@dxos/ai";
+import * as Effect4 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { AiModelResolver, AiService, OpaqueToolkit } from "@dxos/ai";
 import { AnthropicResolver } from "@dxos/ai/resolvers";
+import { Blueprint, FunctionError, InvalidOperationInputError, InvalidOperationOutputError, Operation, OperationRegistry, Trace } from "@dxos/compute";
 import { LifecycleState, Resource } from "@dxos/context";
-import { Database as Database2, Feed, JsonSchema as JsonSchema3, Ref as Ref5 } from "@dxos/echo";
+import { Database as Database2, Feed, JsonSchema, Ref } from "@dxos/echo";
+import { createFeedServiceLayer, EchoClient } from "@dxos/echo-db";
 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 { assertState, failedInvariant, invariant } from "@dxos/invariant";
 import { PublicKey } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+import { ErrorCodec as ErrorCodec2 } from "@dxos/protocols";
 
 // 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 Effect3 from "effect/Effect";
 import * as FiberRef from "effect/FiberRef";
-import * as Layer6 from "effect/Layer";
+import * as Layer3 from "effect/Layer";
 import * as Stream from "effect/Stream";
-import { log as log3 } from "@dxos/log";
+import { FunctionsAiMemoizationMissError, FunctionsAiUpstreamError } from "@dxos/compute";
+import { log } 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 __dxlog_file = "/__w/dxos/dxos/packages/core/compute/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({
+    const send = (body) => Effect3.tryPromise({
       try: () => service.fetch(new Request(url, {
         ...options,
         method: request.method,
@@ -918,21 +159,21 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
         body
       })),
       catch: (cause) => {
-        log3.error("Failed to fetch", {
+        log.error("Failed to fetch", {
           errorSerialized: ErrorCodec.encode(cause)
-        }, {
-          F: __dxlog_file2,
-          L: 43,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 31, S: this });
         return new HttpClientError.RequestError({
           request,
           reason: "Transport",
           cause
         });
       }
-    }).pipe(Effect10.map((response) => HttpClientResponse.fromWeb(request, response)));
+    }).pipe(Effect3.flatMap((response) => (
+      // Inspect the body before handing the response to `@effect/ai` so that structured
+      // upstream errors surface as typed defects (`FunctionsAiUpstreamError` and friends)
+      // rather than as the generic `HttpResponseError` from `@effect/ai/AiError`.
+      Effect3.flatMap(Effect3.promise(() => parseUpstreamError(response)), (typedError) => typedError ? Effect3.die(typedError) : Effect3.succeed(HttpClientResponse.fromWeb(request, response)))
+    )));
     switch (request.body._tag) {
       case "Raw":
       case "Uint8Array":
@@ -940,14 +181,54 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
       case "FormData":
         return send(request.body.formData);
       case "Stream":
-        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect10.flatMap(send));
+        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect3.flatMap(send));
     }
     return send(void 0);
   });
-  static layer = (service) => Layer6.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
+  static layer = (service) => Layer3.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
+};
+var parseUpstreamError = async (response) => {
+  if (response.ok) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.toLowerCase().includes("application/json")) {
+    return void 0;
+  }
+  let body;
+  try {
+    body = await response.clone().json();
+  } catch {
+    return void 0;
+  }
+  if (!body || body.type !== "error" || typeof body.error !== "object" || body.error === null) {
+    return void 0;
+  }
+  const inner = body.error;
+  const message = inner.message ?? `Upstream AI service responded with HTTP ${response.status}`;
+  if (inner.type === "memoization_miss" && typeof inner.cacheKey === "string") {
+    return new FunctionsAiMemoizationMissError({
+      message,
+      context: {
+        cacheKey: inner.cacheKey,
+        status: response.status
+      }
+    });
+  }
+  return new FunctionsAiUpstreamError({
+    message,
+    context: {
+      type: inner.type,
+      status: response.status,
+      ...inner.cacheKey ? {
+        cacheKey: inner.cacheKey
+      } : {}
+    }
+  });
 };
 
 // src/protocol/protocol.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/functions/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.");
@@ -1013,22 +294,22 @@ function _ts_dispose_resources(env) {
     return next();
   })(env);
 }
-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");
+var wrapFunctionHandler = (func, opts = {}) => {
+  if (!Operation.isOperationWithHandler(func)) {
+    throw new TypeError("Expected operation with handler");
   }
+  const serviceTags = func.services.map((service) => service.key);
   return {
     meta: {
-      key: func.key,
-      name: func.name,
-      description: func.description,
-      inputSchema: JsonSchema3.toJsonSchema(func.inputSchema),
-      outputSchema: func.outputSchema === void 0 ? void 0 : JsonSchema3.toJsonSchema(func.outputSchema),
-      services: func.services
+      key: func.meta.key,
+      name: func.meta.name,
+      description: func.meta.description,
+      inputSchema: JsonSchema.toJsonSchema(func.input),
+      outputSchema: func.output === void 0 ? void 0 : JsonSchema.toJsonSchema(func.output),
+      services: func.services.map((service) => service.key)
     },
     handler: async ({ data, context }) => {
-      if ((func.services.includes(Database2.Service.key) || func.services.includes(QueueService.key) || func.services.includes(Feed.Service.key)) && (!context.services.dataService || !context.services.queryService)) {
+      if ((serviceTags.includes(Database2.Service.key) || serviceTags.includes(QueueService.key) || serviceTags.includes(Feed.FeedService.key)) && (!context.services.dataService || !context.services.queryService)) {
         throw new FunctionError({
           message: "Services not provided: dataService, queryService"
         });
@@ -1040,40 +321,49 @@ var wrapFunctionHandler = (func) => {
           hasError: false
         };
         try {
-          if (!SchemaAST2.isAnyKeyword(func.inputSchema.ast)) {
+          if (!SchemaAST.isAnyKeyword(func.input.ast)) {
             try {
-              Schema10.validateSync(func.inputSchema)(data);
+              Schema.validateSync(func.input, {
+                onExcessProperty: "error"
+              })(data);
             } catch (error) {
-              throw new FunctionError({
-                message: "Invalid input schema",
+              throw new InvalidOperationInputError({
+                message: `Operation input did not match schema (${func.meta.key}): ${error.message}`,
                 cause: error
               });
             }
           }
-          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_file3,
-              L: 70,
-              S: void 0,
-              A: [
-                "funcContext.db",
-                "'Database is required for functions with types'"
-              ]
-            });
-            await funcContext.db.graph.schemaRegistry.register(func.types);
+          const funcContext = _ts_add_disposable_resource(env, await new FunctionContext(context, opts).open(), true);
+          const types = [
+            ...opts.types ?? [],
+            ...func.types ?? []
+          ];
+          if (types.length > 0) {
+            invariant(funcContext.db, "Database is required for functions with types", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 137, S: void 0, A: ["funcContext.db", "'Database is required for functions with types'"] });
+            await funcContext.db.graph.schemaRegistry.register(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: dataWithDecodedRefs
-          });
-          if (Effect11.isEffect(result)) {
-            result = await runAndForwardErrors(result.pipe(Effect11.orDie, Effect11.provide(funcContext.createLayer())));
+          const dataWithDecodedRefs = funcContext.db && !SchemaAST.isAnyKeyword(func.input.ast) ? decodeRefsFromSchema(func.input.ast, data, funcContext.db) : data;
+          let result = await func.handler(dataWithDecodedRefs);
+          if (Effect4.isEffect(result)) {
+            result = await runAndForwardErrors(result.pipe(Effect4.orDie, Effect4.provide(funcContext.createLayer())));
+          }
+          if (serviceTags.includes(Database2.Service.key) && funcContext.db) {
+            await funcContext.db.flush({
+              disk: true,
+              indexes: false
+            });
           }
-          if (func.outputSchema && !SchemaAST2.isAnyKeyword(func.outputSchema.ast)) {
-            Schema10.validateSync(func.outputSchema)(result);
+          if (func.output && !SchemaAST.isAnyKeyword(func.output.ast)) {
+            try {
+              Schema.validateSync(func.output, {
+                onExcessProperty: "error"
+              })(result);
+            } catch (error) {
+              throw new InvalidOperationOutputError({
+                message: `Operation output did not match schema (${func.meta.key}): ${error.message}`,
+                cause: error
+              });
+            }
           }
           return result;
         } catch (e) {
@@ -1094,9 +384,11 @@ var FunctionContext = class extends Resource {
   client;
   db;
   queues;
-  constructor(context) {
+  opts;
+  constructor(context, opts) {
     super();
     this.context = context;
+    this.opts = opts;
     if (context.services.dataService && context.services.queryService) {
       this.client = new EchoClient().connectToService({
         dataService: context.services.dataService,
@@ -1108,12 +400,12 @@ var FunctionContext = class extends Resource {
   async _open() {
     await this.client?.open();
     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")),
+      spaceId: this.context.spaceId ?? failedInvariant(),
+      spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant("spaceKey missing in context")),
       reactiveSchemaQuery: false,
       preloadSchemaOnOpen: false
     }) : void 0;
-    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant2("spaceRootUrl missing in context"));
+    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant("spaceRootUrl missing in context"));
     await this.db?.open();
     this.queues = this.client && this.context.spaceId ? this.client.constructQueueFactory(this.context.spaceId) : void 0;
   }
@@ -1126,29 +418,115 @@ var FunctionContext = class extends Resource {
     const dbLayer = this.db ? Database2.layer(this.db) : Database2.notAvailable;
     const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
     const feedLayer = this.queues ? createFeedServiceLayer(this.queues) : Feed.notAvailable;
-    const credentials = dbLayer ? CredentialsService.layerFromDatabase({
+    const credentials = dbLayer ? credentialsLayerFromDatabase({
       caching: true
-    }).pipe(Layer7.provide(dbLayer)) : CredentialsService.configuredLayer([]);
-    const functionInvocationService = MockedFunctionInvocationService;
-    const tracing = TracingService.layerNoop;
-    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);
+    }).pipe(Layer4.provide(dbLayer)) : configuredCredentialsLayer([]);
+    const aiLayer = this.context.services.functionsAiService ? InternalAiServiceLayer(this.context.services.functionsAiService) : AiService.notAvailable;
+    const operationServiceLayer = this.context.services.functionsService ? makeOperationServiceLayer(this.context.services.functionsService) : unavailableOperationServiceLayer;
+    const operationRegistryLayer = this.context.services.functionsService ? makeOperationRegistryLayer(this.context.services.functionsService, this.context.spaceId) : emptyOperationRegistryLayer;
+    const traceWriterLayer = this.context.services.traceService ? makeTraceWriterLayer(this.context.services.traceService) : Trace.writerLayerNoop;
+    log2("Creating function context layer", {
+      traceService: !!this.context.services.traceService,
+      functionsService: !!this.context.services.functionsService,
+      functionsAiService: !!this.context.services.functionsAiService,
+      spaceId: this.context.spaceId,
+      spaceRootUrl: this.context.spaceRootUrl,
+      toolkits: this.opts.toolkits?.length ?? 0,
+      types: this.opts.types?.length ?? 0
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 234, S: this });
+    const blueprintRegistryLayer = this.opts.blueprintRegistry ? Layer4.succeed(Blueprint.RegistryService, this.opts.blueprintRegistry) : Blueprint.RegistryService.notAvailable;
+    return Layer4.mergeAll(
+      dbLayer,
+      queuesLayer,
+      feedLayer,
+      credentials,
+      operationServiceLayer,
+      operationRegistryLayer,
+      aiLayer,
+      OpaqueToolkit.providerLayer(OpaqueToolkit.merge(...this.opts.toolkits ?? [])),
+      traceWriterLayer,
+      blueprintRegistryLayer,
+      // `FunctionInvocationService` is deprecated; new code should yield `Operation.Service`.
+      // The cloudflare wrapper provides only the unavailable layer to satisfy the (still-present)
+      // type union — handlers that yield it will die at invocation time.
+      FunctionInvocationService.layerNotAvailable
+    );
   }
 };
-var MockedFunctionInvocationService = Layer7.succeed(FunctionInvocationService, {
-  invokeFunction: () => Effect11.die("Calling functions from functions is not implemented yet."),
-  resolveFunction: () => Effect11.die("Not implemented.")
+var makeTraceWriterLayer = (traceService) => Layer4.succeed(Trace.TraceService, {
+  write: (eventType, payload) => {
+    log2("Writing trace event", {
+      eventType: eventType.key
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 255, S: void 0 });
+    traceService.write([
+      {
+        key: eventType.key,
+        isEphemeral: eventType.isEphemeral,
+        data: payload
+      }
+    ]);
+  }
+});
+var InternalAiServiceLayer = (functionsAiService) => AiModelResolver.AiModelResolver.buildAiService.pipe(Layer4.provide(AnthropicResolver.make().pipe(Layer4.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(Layer4.provide(FunctionsAiHttpClient.layer(functionsAiService)))))));
+var makeOperationServiceLayer = (functionsService) => {
+  const invokeRemote = async (op, input, options) => {
+    invariant(op.meta.deployedId, `Operation '${op.meta.key}' has no deployedId; cannot invoke remotely.`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 279, S: void 0, A: ["op.meta.deployedId", "`Operation '${op.meta.key}' has no deployedId; cannot invoke remotely.`"] });
+    const result = await functionsService.invoke(op.meta.deployedId, input, {
+      spaceId: options?.spaceId,
+      // Forward the conversation DXN so the remote runtime can rebuild conversation-scoped
+      // services (e.g. `AiContext.Service`) needed by operations like `GetContext`.
+      conversation: options?.conversation
+    });
+    if (result._kind === "success") {
+      return {
+        data: result.data
+      };
+    }
+    return {
+      error: ErrorCodec2.decode(result.error)
+    };
+  };
+  return Layer4.succeed(Operation.Service, {
+    invoke: (op, input, options) => Effect4.tryPromise(() => invokeRemote(op, input, options)).pipe(Effect4.orDie, Effect4.flatMap((outcome) => outcome.error ? Effect4.die(outcome.error) : Effect4.succeed(outcome.data))),
+    schedule: (op, input) => Effect4.sync(() => {
+      invariant(op.meta.deployedId, `Operation '${op.meta.key}' has no deployedId; cannot schedule remotely.`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 298, S: void 0, A: ["op.meta.deployedId", "`Operation '${op.meta.key}' has no deployedId; cannot schedule remotely.`"] });
+      void functionsService.invoke(op.meta.deployedId, input).catch(() => {
+      });
+    }),
+    invokePromise: (op, input, options) => invokeRemote(op, input, options).catch((error) => ({
+      error: error instanceof Error ? error : new Error(String(error))
+    }))
+  });
+};
+var unavailableOperationServiceLayer = Layer4.succeed(Operation.Service, {
+  invoke: () => Effect4.die("Operation.Service is not available: missing functionsService in EDGE context."),
+  schedule: () => Effect4.die("Operation.Service is not available: missing functionsService in EDGE context."),
+  invokePromise: async () => ({
+    error: new Error("Operation.Service is not available: missing functionsService in EDGE context.")
+  })
+});
+var makeOperationRegistryLayer = (functionsService, spaceId) => Layer4.succeed(OperationRegistry.Service, {
+  resolve: (key) => Effect4.gen(function* () {
+    const records = yield* Effect4.tryPromise(() => functionsService.query({
+      spaceId
+    })).pipe(Effect4.orDie);
+    const match = records.find((record) => Operation.getKey(record) === key);
+    return match ? Option.some(Operation.deserialize(match)) : Option.none();
+  })
+});
+var emptyOperationRegistryLayer = Layer4.succeed(OperationRegistry.Service, {
+  resolve: () => Effect4.succeed(Option.none())
 });
 var decodeRefsFromSchema = (ast, value2, db) => {
   if (value2 == null) {
     return value2;
   }
-  const encoded = SchemaAST2.encodedBoundAST(ast);
-  if (Ref5.isRefType(encoded)) {
-    if (Ref5.isRef(value2)) {
+  const encoded = SchemaAST.encodedBoundAST(ast);
+  if (Ref.isRefType(encoded)) {
+    if (Ref.isRef(value2)) {
       return value2;
     }
     if (typeof value2 === "object" && value2 !== null && typeof value2["/"] === "string") {
@@ -1169,7 +547,7 @@ var decodeRefsFromSchema = (ast, value2, db) => {
       const result = {
         ...value2
       };
-      for (const prop of SchemaAST2.getPropertySignatures(encoded)) {
+      for (const prop of SchemaAST.getPropertySignatures(encoded)) {
         const key = prop.name.toString();
         if (key in result) {
           result[key] = decodeRefsFromSchema(prop.type, result[key], db);
@@ -1188,7 +566,7 @@ var decodeRefsFromSchema = (ast, value2, db) => {
       return value2;
     }
     case "Union": {
-      const nonUndefined = encoded.types.filter((t) => !SchemaAST2.isUndefinedKeyword(t));
+      const nonUndefined = encoded.types.filter((t) => !SchemaAST.isUndefinedKeyword(t));
       if (nonUndefined.length === 1) {
         return decodeRefsFromSchema(nonUndefined[0], value2, db);
       }
@@ -1206,37 +584,18 @@ var decodeRefsFromSchema = (ast, value2, db) => {
   }
 };
 export {
-  ComputeEvent,
-  ComputeEventLogger,
-  ComputeEventPayload,
   ConfiguredCredentialsService,
-  ContextQueueService,
-  CredentialsService,
-  ExampleFunctions,
   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,
+  configuredCredentialsLayer,
+  credentialsLayerConfig,
+  credentialsLayerFromDatabase,
+  feedServiceFromQueueServiceLayer,
   getUserFunctionIdInMetadata,
-  logCustomEvent,
-  serializeFunction,
   setUserFunctionIdInMetadata,
-  toOperation,
   withAuthorization,
   wrapFunctionHandler
 };