@dxos/functions 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/dist/lib/neutral/index.mjs

@@ -1,376 +1,12 @@
-import {
-  EventType,
-  OperationEnd,
-  OperationStart,
-  Trace_exports,
-  write,
-  writerLayerNoop
-} from "./chunk-5T7GOX2V.mjs";
-import {
-  Fibonacci,
-  Reply,
-  Sleep
-} from "./chunk-IVDUS56O.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// 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,
-      message: `Service not available: ${service}`
-    });
-  }
-};
-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/index.ts
-import { OperationHandlerSet } from "@dxos/operation";
-var ExampleHandlers = OperationHandlerSet.lazy(() => import("./fib-N45KAC7C.mjs"), () => import("./reply-EUEPKNJF.mjs"), () => import("./sleep-PUK3D4FF.mjs"));
-
-// src/process/Process.ts
-var Process_exports = {};
-__export(Process_exports, {
-  ExitedEvent: () => ExitedEvent,
-  ID: () => ID,
-  ProcessMonitorService: () => ProcessMonitorService,
-  ProcessTypeId: () => ProcessTypeId,
-  SpawnedEvent: () => SpawnedEvent,
-  State: () => State,
-  fromOperation: () => fromOperation,
-  isProcess: () => isProcess,
-  make: () => make,
-  prettyProcessTree: () => prettyProcessTree
-});
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { assertArgument } from "@dxos/invariant";
-import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/operation";
-var ID = Schema.String.pipe(Schema.brand("ProcessId"));
-var ProcessTypeId = "~@dxos/functions/Process";
-var isProcess = (executable) => typeof executable === "object" && executable !== null && ProcessTypeId in executable;
-var make = (opts, create) => {
-  assertArgument(/^[a-z0-9]([a-z0-9.\-/]*[a-z0-9])?$/i.test(opts.key), "key", "Invalid key");
-  return {
-    [ProcessTypeId]: {},
-    ...opts,
-    create: (ctx) => create(ctx).pipe(Effect.map((partial) => ({
-      onSpawn: () => Effect.void,
-      onInput: () => Effect.void,
-      onAlarm: () => Effect.void,
-      onChildEvent: () => Effect.void,
-      ...partial
-    })))
-  };
-};
-var fromOperation = (op, handler) => make({
-  key: op.meta.key,
-  input: op.input,
-  output: op.output,
-  services: op.services
-}, (ctx) => Effect.gen(function* () {
-  const semaphore = yield* Effect.makeSemaphore(1);
-  return {
-    onInput: (input) => Effect.gen(function* () {
-      yield* write(OperationStart, {
-        key: op.meta.key,
-        name: op.meta.name
-      });
-      const opHandler = yield* OperationHandlerSet2.getHandler(handler, op).pipe(Effect.orDie);
-      const output = yield* opHandler.handler(input).pipe(Effect.orDie);
-      ctx.submitOutput(output);
-      ctx.succeed();
-      yield* write(OperationEnd, {
-        key: op.meta.key,
-        name: op.meta.name,
-        outcome: "success"
-      });
-    }).pipe(Effect.catchAllDefect((defect) => Effect.gen(function* () {
-      const errorMessage = defect instanceof Error ? defect.message : String(defect);
-      yield* write(OperationEnd, {
-        key: op.meta.key,
-        name: op.meta.name,
-        outcome: "failure",
-        error: errorMessage
-      });
-      return yield* Effect.die(defect);
-    })), semaphore.withPermits(1))
-  };
-}));
-var State = /* @__PURE__ */ (function(State2) {
-  State2["RUNNING"] = "RUNNING";
-  State2["HYBERNATING"] = "HYBERNATING";
-  State2["IDLE"] = "IDLE";
-  State2["TERMINATING"] = "TERMINATING";
-  State2["TERMINATED"] = "TERMINATED";
-  State2["SUCCEEDED"] = "SUCCEEDED";
-  State2["FAILED"] = "FAILED";
-  return State2;
-})({});
-var ProcessMonitorService = class extends Context.Tag("@dxos/functions/ProcessMonitorService")() {
-};
-var SpawnedEvent = EventType("process.spawned", {
-  schema: Schema.Void,
-  isEphemeral: false
-});
-var ExitedEvent = EventType("process.exited", {
-  schema: Schema.Struct({
-    outcome: Schema.Literal("succeeded", "failed", "terminated")
-  }),
-  isEphemeral: false
-});
-var prettyProcessTree = (tree) => {
-  if (tree.length === 0) {
-    return "";
-  }
-  const pidSet = new Set(tree.map((node) => node.pid));
-  const childrenByParent = /* @__PURE__ */ new Map();
-  const roots = [];
-  for (const node of tree) {
-    const parent = node.parentPid;
-    if (parent === null || !pidSet.has(parent)) {
-      roots.push(node);
-      continue;
-    }
-    const key2 = String(parent);
-    const siblings = childrenByParent.get(key2) ?? [];
-    siblings.push(node);
-    childrenByParent.set(key2, siblings);
-  }
-  const byPid = (a, b) => String(a.pid).localeCompare(String(b.pid));
-  roots.sort(byPid);
-  for (const siblings of childrenByParent.values()) {
-    siblings.sort(byPid);
-  }
-  const formatLabel = (node) => {
-    const idShort = String(node.pid).slice(0, 6);
-    const parts = [
-      idShort,
-      node.state
-    ];
-    if (node.params.name != null && node.params.name !== "") {
-      parts.push(node.params.name);
-    }
-    if (node.error != null) {
-      parts.push(`(${node.error})`);
-    }
-    const { inputCount, outputCount, wallTime } = node.metrics;
-    parts.push(`[in:${inputCount} out:${outputCount} wall:${Math.round(wallTime)}ms]`);
-    return parts.join(" ");
-  };
-  const lines = [];
-  const walk = (node, prefix, isLast, isRoot) => {
-    if (isRoot) {
-      lines.push(`- ${formatLabel(node)}`);
-    } else {
-      const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      lines.push(`${prefix}${branch}${formatLabel(node)}`);
-    }
-    const children = childrenByParent.get(String(node.pid)) ?? [];
-    const nextPrefix = isRoot ? "  " : `${prefix}${isLast ? "    " : "\u2502   "}`;
-    children.forEach((child, index) => {
-      walk(child, nextPrefix, index === children.length - 1, false);
-    });
-  };
-  for (const root of roots) {
-    walk(root, "", true, true);
-  }
-  return lines.join("\n");
-};
-
-// src/process/ServiceResolver.ts
-var ServiceResolver_exports = {};
-__export(ServiceResolver_exports, {
-  ServiceResolver: () => ServiceResolver,
-  compose: () => compose,
-  empty: () => empty2,
-  fromContext: () => fromContext,
-  fromRequirements: () => fromRequirements,
-  layerRequirements: () => layerRequirements,
-  make: () => make3,
-  resolve: () => resolve,
-  resolveAll: () => resolveAll,
-  succeed: () => succeed
-});
-import * as Context2 from "effect/Context";
-import * as Effect2 from "effect/Effect";
-import * as Either from "effect/Either";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-var ServiceResolverTypeId = "~@dxos/functions/ServiceResolver";
-var ServiceResolver = Context2.GenericTag("@dxos/functions/ServiceResolver");
-var resolve = Effect2.serviceFunctionEffect(ServiceResolver, (_) => _.resolve);
-var resolveAll = (tags, context) => Effect2.gen(function* () {
-  const services = yield* Effect2.forEach(tags, (tag) => resolve(tag, context).pipe(Effect2.map((service) => Context2.make(tag, service))));
-  return Context2.mergeAll(...services);
-});
-var succeed = (tag, getService) => {
-  return make3((tag1, context) => {
-    if (tag1.key !== tag.key) {
-      return Effect2.fail(new ServiceNotAvailableError(`Service not available: ${String(tag.key ?? tag)}`));
-    }
-    const service = getService(context);
-    return service;
-  });
-};
-var make3 = (resolveFn) => ({
-  [ServiceResolverTypeId]: ServiceResolverTypeId,
-  resolve: resolveFn
-});
-var fromContext = (ctx) => make3((tag, context) => Effect2.gen(function* () {
-  const service = Context2.getOption(ctx, tag);
-  if (Option.isNone(service)) {
-    return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-  }
-  return service.value;
-}));
-var fromRequirements = (...tags) => Effect2.contextWith((parentCtx) => {
-  const available = new Set(tags.map((tag) => tag.key));
-  return make3((tag, context) => Effect2.gen(function* () {
-    let result = Context2.empty();
-    if (!available.has(tag.key)) {
-      return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-    }
-    const service = Context2.getOption(parentCtx, tag);
-    if (Option.isNone(service)) {
-      return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-    }
-    return service.value;
-  }));
-});
-var layerRequirements = (...tags) => Layer.effect(ServiceResolver, fromRequirements(...tags));
-var compose = (...resolvers) => make3((tag, context) => Effect2.gen(function* () {
-  for (const resolver of resolvers) {
-    const single = yield* resolver.resolve(tag, context).pipe(Effect2.either);
-    if (Either.isRight(single)) {
-      return single.right;
-    }
-  }
-  return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-}));
-var empty2 = make3((tag, context) => {
-  return Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-});
-
-// src/process/StorageService.ts
-import * as Context3 from "effect/Context";
-import * as Effect3 from "effect/Effect";
-import * as Option2 from "effect/Option";
-import * as Pipeable from "effect/Pipeable";
-var StorageService = class extends Context3.Tag("@dxos/functions/StorageService")() {
-};
-var get = Effect3.serviceFunctionEffect(StorageService, (_) => _.get);
-var set = Effect3.serviceFunctionEffect(StorageService, (_) => _.set);
-var deleteKey = Effect3.serviceFunctionEffect(StorageService, (_) => _.delete);
-var list = Effect3.serviceFunctionEffect(StorageService, (_) => _.list);
-var clear = Effect3.serviceFunctionEffect(StorageService, (_) => _.clear);
-var key = (schema, key2) => {
-  return {
-    key: key2,
-    get: get(schema, key2),
-    set: (value2) => set(schema, key2, value2),
-    delete: () => deleteKey(key2),
-    pipe(...args) {
-      return Pipeable.pipeArguments(this, arguments);
-    }
-  };
-};
-var withDefault = (getDefault) => (key2) => {
-  return {
-    key: key2.key,
-    get: key2.get.pipe(Effect3.map(Option2.getOrElse(() => getDefault()))),
-    set: (value2) => key2.set(value2),
-    delete: () => key2.delete(),
-    pipe(...args) {
-      return Pipeable.pipeArguments(this, arguments);
-    }
-  };
-};
-
 // src/services/credentials.ts
 import * as HttpClient from "@effect/platform/HttpClient";
 import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as Context4 from "effect/Context";
-import * as Effect4 from "effect/Effect";
-import * as Layer2 from "effect/Layer";
+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 Context4.Tag("@dxos/functions/CredentialsService")() {
-  static getCredential = (query) => Effect4.gen(function* () {
-    const credentials = yield* _CredentialsService;
-    return yield* Effect4.promise(() => credentials.getCredential(query));
-  });
-  static getApiKey = (query) => Effect4.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) => Layer2.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
-  static layerConfig = (credentials) => Layer2.effect(_CredentialsService, Effect4.gen(function* () {
-    const serviceCredentials = yield* Effect4.forEach(credentials, ({ service, apiKey }) => Effect4.gen(function* () {
-      return {
-        service,
-        apiKey: Redacted.value(yield* apiKey)
-      };
-    }));
-    return new ConfiguredCredentialsService(serviceCredentials);
-  }));
-  static layerFromDatabase = ({ caching = false } = {}) => Layer2.effect(_CredentialsService, Effect4.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 = []) {
@@ -395,484 +31,77 @@ 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 Context6 from "effect/Context";
-import * as Effect6 from "effect/Effect";
-import * as Layer4 from "effect/Layer";
-import * as Schema2 from "effect/Schema";
-import { Obj as Obj2, Type } from "@dxos/echo";
-import { invariant } from "@dxos/invariant";
-import { LogLevel, log } from "@dxos/log";
-
-// src/services/tracing.ts
-import * as Context5 from "effect/Context";
-import * as Effect5 from "effect/Effect";
-import * as Layer3 from "effect/Layer";
-import { AgentStatus } from "@dxos/ai";
-import { Obj } from "@dxos/echo";
-import { ObjectId } from "@dxos/keys";
-import { Message } from "@dxos/types";
-var TracingService = class _TracingService extends Context5.Tag("@dxos/functions/TracingService")() {
-  static noop = {
-    getTraceContext: () => ({}),
-    write: () => {
-    },
-    ephemeral: () => {
-    },
-    traceInvocationStart: () => Effect5.sync(() => ({
-      invocationId: ObjectId.random(),
-      invocationTraceQueue: void 0
-    })),
-    traceInvocationEnd: () => Effect5.sync(() => {
-    })
-  };
-  static layerNoop = Layer3.succeed(_TracingService, _TracingService.noop);
-  /**
-  * Creates a TracingService layer that emits events to the parent tracing service.
-  */
-  static layerSubframe = (mapContext) => Layer3.effect(_TracingService, Effect5.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),
-      ephemeral: (event, context2) => tracing.ephemeral(event, context2),
-      getTraceContext: () => context,
-      traceInvocationStart: () => Effect5.die("Tracing invocation inside another invocation is not supported."),
-      traceInvocationEnd: () => Effect5.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 = Effect5.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj.make(AgentStatus, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      toolCallId: tracing.getTraceContext().toolCallId,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      ...data
-    }), tracing.getTraceContext());
-  });
-  static emitConverationMessage = Effect5.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.write(Obj.make(Message.Message, {
-      parentMessage: tracing.getTraceContext().parentMessage,
-      ...data,
-      properties: {
-        [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
-        ...data.properties
-      }
-    }), tracing.getTraceContext());
-  });
-  static emitEphemeralMessage = Effect5.fnUntraced(function* (data) {
-    const tracing = yield* _TracingService;
-    tracing.ephemeral(data, 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 = Schema2.Union(Schema2.Struct({
-  type: Schema2.Literal("begin-compute"),
-  nodeId: Schema2.String,
-  /**
-   * Names of the inputs begin computed.
-   */
-  inputs: Schema2.Array(Schema2.String)
-}), Schema2.Struct({
-  type: Schema2.Literal("end-compute"),
-  nodeId: Schema2.String,
-  /**
-   * Names of the outputs computed.
-   */
-  outputs: Schema2.Array(Schema2.String)
-}), Schema2.Struct({
-  type: Schema2.Literal("compute-input"),
-  nodeId: Schema2.String,
-  property: Schema2.String,
-  value: Schema2.Any
-}), Schema2.Struct({
-  type: Schema2.Literal("compute-output"),
-  nodeId: Schema2.String,
-  property: Schema2.String,
-  value: Schema2.Any
-}), Schema2.Struct({
-  type: Schema2.Literal("custom"),
-  nodeId: Schema2.String,
-  event: Schema2.Any
-}));
-var ComputeEvent = Schema2.Struct({
-  payload: ComputeEventPayload
-}).pipe(Type.object({
-  typename: "org.dxos.type.computeEvent",
-  version: "0.1.0"
+  return new ConfiguredCredentialsService(serviceCredentials);
 }));
-var ComputeEventLogger = class _ComputeEventLogger extends Context6.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 = Layer4.effect(_ComputeEventLogger, Effect6.gen(function* () {
-    const tracing = yield* TracingService;
-    return {
-      log: (event) => {
-        tracing.write(Obj2.make(ComputeEvent, {
-          payload: event
-        }), tracing.getTraceContext());
-      },
-      nodeId: void 0
-    };
-  }));
-};
-var logCustomEvent = (data) => Effect6.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 = () => Effect6.catchAll((error) => Effect6.gen(function* () {
-  log.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]: log.warn,
-    [LogLevel.VERBOSE]: log.verbose,
-    [LogLevel.DEBUG]: log.debug,
-    [LogLevel.INFO]: log.info,
-    [LogLevel.ERROR]: log.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 Context7 from "effect/Context";
-import * as Effect7 from "effect/Effect";
-import * as Layer5 from "effect/Layer";
-var FunctionInvocationService = class _FunctionInvocationService extends Context7.Tag("@dxos/functions/FunctionInvocationService")() {
-  static layerNotAvailable = Layer5.succeed(_FunctionInvocationService, {
-    invokeFunction: () => Effect7.die("FunctionInvocationService is not avaialble."),
-    resolveFunction: () => Effect7.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) => Effect7.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
-  static resolveFunction = (key2) => Effect7.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key2);
+  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 Context8 from "effect/Context";
-import * as Effect8 from "effect/Effect";
-import * as Layer6 from "effect/Layer";
-import { createFeedServiceLayer } from "@dxos/echo-db";
-var QueueService = class _QueueService extends Context8.Tag("@dxos/functions/QueueService")() {
-  static notAvailable = Layer6.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) => Layer6.succeed(_QueueService, _QueueService.make(queues, queue));
-  /**
-  * Gets a queue by its DXN.
-  */
-  static getQueue = (dxn) => _QueueService.pipe(Effect8.map(({ queues }) => queues.get(dxn)));
-  /**
-  * Creates a new queue.
-  */
-  static createQueue = (options) => _QueueService.pipe(Effect8.map(({ queues }) => queues.create(options)));
-  static append = (queue, objects) => Effect8.promise(() => queue.append(objects));
-};
-var ContextQueueService = class _ContextQueueService extends Context8.Tag("@dxos/functions/ContextQueueService")() {
-  static layer = (queue) => Layer6.succeed(_ContextQueueService, {
-    queue
-  });
-};
-var feedServiceFromQueueServiceLayer = Layer6.unwrapEffect(Effect8.gen(function* () {
-  const { queues } = yield* QueueService;
-  return createFeedServiceLayer(queues);
-}));
-
-// src/types/Script.ts
-var Script_exports = {};
-__export(Script_exports, {
-  Script: () => Script,
-  make: () => make5
-});
-import * as Schema3 from "effect/Schema";
-import { Annotation, Obj as Obj3, Ref, Type as Type2 } from "@dxos/echo";
-import { FormInputAnnotation } from "@dxos/echo/internal";
-import { Text } from "@dxos/schema";
-var Script = Schema3.Struct({
-  name: Schema3.String.pipe(Schema3.optional),
-  description: Schema3.String.pipe(Schema3.optional),
-  // TODO(burdon): Change to hash of deployed content.
-  // Whether source has changed since last deploy.
-  changed: Schema3.Boolean.pipe(FormInputAnnotation.set(false), Schema3.optional),
-  source: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false))
-}).pipe(Type2.object({
-  typename: "org.dxos.type.script",
-  version: "0.1.0"
-}), Annotation.LabelAnnotation.set([
-  "name"
-]), Annotation.IconAnnotation.set({
-  icon: "ph--code--regular",
-  hue: "sky"
-}));
-var make5 = ({ source = "", ...props } = {}) => Obj3.make(Script, {
-  ...props,
-  source: Ref.make(Text.make({
-    content: source
-  }))
-});
-
-// 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: () => make6
-});
-import * as Schema4 from "effect/Schema";
-import * as SchemaAST from "effect/SchemaAST";
-import { Annotation as Annotation2, Obj as Obj4, QueryAST, Ref as Ref2, Type as Type3 } from "@dxos/echo";
-import { OptionsAnnotationId, SystemTypeAnnotation } from "@dxos/echo/internal";
-import { DXN } from "@dxos/keys";
-var Kinds = [
-  "email",
-  "queue",
-  "subscription",
-  "timer",
-  "webhook"
-];
-var kindLiteralAnnotations = {
-  title: "Kind"
-};
-var EmailSpec = Schema4.Struct({
-  kind: Schema4.Literal("email").annotations(kindLiteralAnnotations)
-});
-var QueueSpec = Schema4.Struct({
-  kind: Schema4.Literal("queue").annotations(kindLiteralAnnotations),
-  // TODO(dmaretskyi): Rename to `feed` and change to a reference.
-  queue: DXN.Schema
-});
-var SubscriptionSpec = Schema4.Struct({
-  kind: Schema4.Literal("subscription").annotations(kindLiteralAnnotations),
-  query: Schema4.Struct({
-    raw: Schema4.optional(Schema4.String.annotations({
-      title: "Query"
-    })),
-    ast: QueryAST.Query
-  }),
-  options: Schema4.optional(Schema4.Struct({
-    // Watch changes to object (not just creation).
-    deep: Schema4.optional(Schema4.Boolean.annotations({
-      title: "Nested"
-    })),
-    // Debounce changes (delay in ms).
-    delay: Schema4.optional(Schema4.Number.annotations({
-      title: "Delay"
-    }))
-  }).annotations({
-    title: "Options"
-  }))
-});
-var TimerSpec = Schema4.Struct({
-  kind: Schema4.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema4.String.annotations({
-    title: "Cron",
-    [SchemaAST.ExamplesAnnotationId]: [
-      "0 0 * * *"
-    ]
-  })
-});
-var WebhookSpec = Schema4.Struct({
-  kind: Schema4.Literal("webhook").annotations(kindLiteralAnnotations),
-  method: Schema4.optional(Schema4.String.annotations({
-    title: "Method",
-    [OptionsAnnotationId]: [
-      "GET",
-      "POST"
-    ]
-  })),
-  port: Schema4.optional(Schema4.Number.annotations({
-    title: "Port"
-  }))
-});
-var Spec = Schema4.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
-  title: "Trigger"
-});
-var TriggerSchema = Schema4.Struct({
-  /**
-  * Function or workflow to invoke.
-  */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema4.optional(Ref2.Ref(Obj4.Unknown).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: Schema4.optional(Schema4.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: Schema4.optional(Schema4.Boolean.annotations({
-    title: "Enabled"
-  })),
-  spec: Schema4.optional(Spec),
-  concurrency: Schema4.optional(Schema4.Number.annotations({
-    title: "Concurrency",
-    default: 1,
-    description: "Maximum number of concurrent invocations of the trigger. For Feed triggers, this will process Feed 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: Schema4.optional(Schema4.Record({
-    key: Schema4.String,
-    value: Schema4.Any
-  }))
-}).pipe(Type3.object({
-  typename: "org.dxos.type.trigger",
-  version: "0.1.0"
-}), Annotation2.IconAnnotation.set({
-  icon: "ph--lightning--regular",
-  hue: "yellow"
-}), SystemTypeAnnotation.set(true));
-var Trigger = TriggerSchema;
-var make6 = (props) => Obj4.make(Trigger, props);
+import { QueueService, feedServiceFromQueueServiceLayer } from "@dxos/echo-db";
 
-// src/types/TriggerEvent.ts
-var TriggerEvent_exports = {};
-__export(TriggerEvent_exports, {
-  EmailEvent: () => EmailEvent,
-  QueueEvent: () => QueueEvent,
-  SubscriptionEvent: () => SubscriptionEvent,
-  TimerEvent: () => TimerEvent,
-  TriggerEvent: () => TriggerEvent,
-  WebhookEvent: () => WebhookEvent
-});
-import * as Schema5 from "effect/Schema";
-import { DXN as DXN2, Obj as Obj5, Ref as Ref3 } from "@dxos/echo";
-var EmailEvent = Schema5.Struct({
-  from: Schema5.String,
-  to: Schema5.String,
-  subject: Schema5.String,
-  created: Schema5.String,
-  body: Schema5.String
-});
-var QueueEvent = Schema5.Struct({
-  queue: DXN2.Schema,
-  item: Schema5.Any,
-  cursor: Schema5.String
-});
-var SubscriptionEvent = Schema5.Struct({
-  /**
-  * Type of the mutation.
-  */
-  // TODO(dmaretskyi): Specify enum.
-  type: Schema5.String,
-  /**
-  * Reference to the object that was changed or created.
-  */
-  subject: Ref3.Ref(Obj5.Unknown),
-  /**
-  * @deprecated
-  */
-  changedObjectId: Schema5.optional(Schema5.String)
-});
-var TimerEvent = Schema5.Struct({
-  tick: Schema5.Number
-});
-var WebhookEvent = Schema5.Struct({
-  url: Schema5.String,
-  method: Schema5.Literal("GET", "POST"),
-  headers: Schema5.Record({
-    key: Schema5.String,
-    value: Schema5.String
-  }),
-  bodyText: Schema5.String
-});
-var TriggerEvent = Schema5.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
+// 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((key2) => key2.source === FUNCTIONS_META_KEY)?.id;
+  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
 };
 var setUserFunctionIdInMetadata = (meta, functionId) => {
-  const key2 = meta.keys.find((key3) => key3.source === FUNCTIONS_META_KEY);
-  if (key2) {
-    if (key2.id !== functionId) {
+  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionId) {
       throw new Error("Metadata mismatch");
     }
   } else {
@@ -885,40 +114,44 @@ var setUserFunctionIdInMetadata = (meta, functionId) => {
 
 // src/protocol/protocol.ts
 import * as AnthropicClient from "@effect/ai-anthropic/AnthropicClient";
-import * as Effect10 from "effect/Effect";
-import * as Layer8 from "effect/Layer";
-import * as Schema6 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 { FunctionError, InvalidOperationInputError, InvalidOperationOutputError, Operation, OperationRegistry, Trace } from "@dxos/compute";
 import { LifecycleState, Resource } from "@dxos/context";
-import { Database as Database2, Feed, JsonSchema, Ref as Ref4 } from "@dxos/echo";
-import { EchoClient, createFeedServiceLayer as createFeedServiceLayer2 } from "@dxos/echo-db";
+import { Database as Database2, Feed, JsonSchema, Ref } from "@dxos/echo";
+import { createFeedServiceLayer, EchoClient } from "@dxos/echo-db";
 import { refFromEncodedReference } from "@dxos/echo/internal";
 import { runAndForwardErrors } from "@dxos/effect";
-import { assertState, failedInvariant, invariant as invariant2 } from "@dxos/invariant";
+import { assertState, failedInvariant, invariant } from "@dxos/invariant";
 import { PublicKey } from "@dxos/keys";
-import { Operation } from "@dxos/operation";
+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 Effect9 from "effect/Effect";
+import * as Effect3 from "effect/Effect";
 import * as FiberRef from "effect/FiberRef";
-import * as Layer7 from "effect/Layer";
+import * as Layer3 from "effect/Layer";
 import * as Stream from "effect/Stream";
-import { log as log2 } 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) => Effect9.tryPromise({
+    const send = (body) => Effect3.tryPromise({
       try: () => service.fetch(new Request(url, {
         ...options,
         method: request.method,
@@ -926,21 +159,21 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
         body
       })),
       catch: (cause) => {
-        log2.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(Effect9.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":
@@ -948,14 +181,54 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
       case "FormData":
         return send(request.body.formData);
       case "Stream":
-        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect9.flatMap(send));
+        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect3.flatMap(send));
     }
     return send(void 0);
   });
-  static layer = (service) => Layer7.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.");
@@ -995,7 +268,7 @@ function _ts_dispose_resources(env) {
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
   };
   return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
-    function fail2(e) {
+    function fail(e) {
       env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
       env2.hasError = true;
     }
@@ -1007,12 +280,12 @@ function _ts_dispose_resources(env) {
           if (r.dispose) {
             var result = r.dispose.call(r.value);
             if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-              fail2(e);
+              fail(e);
               return next();
             });
           } else s |= 1;
         } catch (e) {
-          fail2(e);
+          fail(e);
         }
       }
       if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
@@ -1021,8 +294,7 @@ function _ts_dispose_resources(env) {
     return next();
   })(env);
 }
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
-var wrapFunctionHandler = (func) => {
+var wrapFunctionHandler = (func, opts = {}) => {
   if (!Operation.isOperationWithHandler(func)) {
     throw new TypeError("Expected operation with handler");
   }
@@ -1049,36 +321,49 @@ var wrapFunctionHandler = (func) => {
           hasError: false
         };
         try {
-          if (!SchemaAST2.isAnyKeyword(func.input.ast)) {
+          if (!SchemaAST.isAnyKeyword(func.input.ast)) {
             try {
-              Schema6.validateSync(func.input)(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: 73,
-              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.input.ast) ? decodeRefsFromSchema(func.input.ast, data, funcContext.db) : data;
+          const dataWithDecodedRefs = funcContext.db && !SchemaAST.isAnyKeyword(func.input.ast) ? decodeRefsFromSchema(func.input.ast, data, funcContext.db) : data;
           let result = await func.handler(dataWithDecodedRefs);
-          if (Effect10.isEffect(result)) {
-            result = await runAndForwardErrors(result.pipe(Effect10.orDie, Effect10.provide(funcContext.createLayer())));
+          if (Effect4.isEffect(result)) {
+            result = await runAndForwardErrors(result.pipe(Effect4.orDie, Effect4.provide(funcContext.createLayer())));
           }
-          if (func.output && !SchemaAST2.isAnyKeyword(func.output.ast)) {
-            Schema6.validateSync(func.output)(result);
+          if (serviceTags.includes(Database2.Service.key) && funcContext.db) {
+            await funcContext.db.flush({
+              disk: true,
+              indexes: false
+            });
+          }
+          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) {
@@ -1099,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,
@@ -1130,39 +417,111 @@ var FunctionContext = class extends Resource {
     assertState(this._lifecycleState === LifecycleState.OPEN, "FunctionContext is not open");
     const dbLayer = this.db ? Database2.layer(this.db) : Database2.notAvailable;
     const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
-    const feedLayer = this.queues ? createFeedServiceLayer2(this.queues) : Feed.notAvailable;
-    const credentials = dbLayer ? CredentialsService.layerFromDatabase({
+    const feedLayer = this.queues ? createFeedServiceLayer(this.queues) : Feed.notAvailable;
+    const credentials = dbLayer ? credentialsLayerFromDatabase({
       caching: true
-    }).pipe(Layer8.provide(dbLayer)) : CredentialsService.configuredLayer([]);
-    const functionInvocationService = MockedFunctionInvocationService;
-    const tracing = TracingService.layerNoop;
-    const aiLayer = this.context.services.functionsAiService ? AiModelResolver.AiModelResolver.buildAiService.pipe(Layer8.provide(AnthropicResolver.make().pipe(Layer8.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(Layer8.provide(FunctionsAiHttpClient.layer(this.context.services.functionsAiService))))))) : AiService.notAvailable;
-    return Layer8.mergeAll(
+    }).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 });
+    return Layer4.mergeAll(
       dbLayer,
       queuesLayer,
       feedLayer,
       credentials,
-      functionInvocationService,
+      operationServiceLayer,
+      operationRegistryLayer,
       aiLayer,
-      tracing,
-      writerLayerNoop
+      OpaqueToolkit.providerLayer(OpaqueToolkit.merge(...this.opts.toolkits ?? [])),
+      traceWriterLayer,
+      // `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 = Layer8.succeed(FunctionInvocationService, {
-  invokeFunction: () => Effect10.die("Calling functions from functions is not implemented yet."),
-  resolveFunction: () => Effect10.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: 254, 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: 278, 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
+    });
+    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: 294, 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 (Ref4.isRefType(encoded)) {
-    if (Ref4.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") {
@@ -1183,10 +542,10 @@ var decodeRefsFromSchema = (ast, value2, db) => {
       const result = {
         ...value2
       };
-      for (const prop of SchemaAST2.getPropertySignatures(encoded)) {
-        const key2 = prop.name.toString();
-        if (key2 in result) {
-          result[key2] = decodeRefsFromSchema(prop.type, result[key2], db);
+      for (const prop of SchemaAST.getPropertySignatures(encoded)) {
+        const key = prop.name.toString();
+        if (key in result) {
+          result[key] = decodeRefsFromSchema(prop.type, result[key], db);
         }
       }
       return result;
@@ -1202,7 +561,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);
       }
@@ -1220,47 +579,19 @@ var decodeRefsFromSchema = (ast, value2, db) => {
   }
 };
 export {
-  ComputeEvent,
-  ComputeEventLogger,
-  ComputeEventPayload,
   ConfiguredCredentialsService,
-  ContextQueueService,
-  CredentialsService,
-  ExampleHandlers,
   FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
-  Fibonacci,
-  FunctionError,
   FunctionInvocationService,
-  FunctionNotFoundError,
   MESSAGE_PROPERTY_TOOL_CALL_ID,
-  Process_exports as Process,
   QueueService,
-  Reply,
-  Script_exports as Script,
-  ServiceNotAvailableError,
-  ServiceResolver_exports as ServiceResolver,
-  Sleep,
-  StorageService,
-  Trace_exports as Trace,
-  TracingService,
-  Trigger_exports as Trigger,
-  TriggerEvent_exports as TriggerEvent,
-  TriggerStateNotFoundError,
-  clear,
-  createDefectLogger,
-  createEventLogger,
-  deleteKey,
+  configuredCredentialsLayer,
+  credentialsLayerConfig,
+  credentialsLayerFromDatabase,
   feedServiceFromQueueServiceLayer,
-  get,
   getUserFunctionIdInMetadata,
-  key,
-  list,
-  logCustomEvent,
-  set,
   setUserFunctionIdInMetadata,
   withAuthorization,
-  withDefault,
   wrapFunctionHandler
 };
 //# sourceMappingURL=index.mjs.map