@effect-agent/platform-cloudflare 0.1.0-beta.14 → 0.1.0-beta.16

package/src/layers.ts

@@ -1,16 +1,18 @@
 import { ConversationId } from "@effect-agent/core";
 import {
   AgentBindingResolver,
-  ConversationStore,
   DurableAgentRuntime,
   DurableRuntimeConfig,
   DurableRuntimeFailpoint,
   ProducerId,
-  SubmissionLedger,
+  operationAuthorizerLayer,
   ToolReconciler,
-  WakeScheduler,
+  type ConversationStore,
   type DurableRuntimeFailpointHandler,
+  type OperationAuthorizerService,
   type ResolvedBinding,
+  type SubmissionLedger,
+  type WakeScheduler,
 } from "@effect-agent/session";
 import {
   conversationStoreLayer,
@@ -28,11 +30,16 @@ import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
 import { Context, Duration, Effect, Layer, Schema } from "effect";
 
-import { ConversationMaintenance, DurableAlarmService } from "./alarm.ts";
+import {
+  ConversationMaintenance,
+  ConversationMaintenanceFailpoint,
+  DurableAlarmService,
+  type ConversationMaintenanceFailpointHandler,
+} from "./alarm.ts";
 import {
   ConversationObjectIdentity,
-  ConversationObjectNamespace,
   DurableObjectContext,
+  type ConversationObjectNamespace,
 } from "./bindings.ts";
 import {
   CLOUDFLARE_RUNTIME_DEFAULTS,
@@ -40,6 +47,7 @@ import {
   CloudflareDurableRuntimeConfigValue,
   CloudflarePlatformConfigError,
 } from "./config.ts";
+import { ProgressWaitRegistry } from "./progress-wait.ts";
 import { conversationPortTransportLayer } from "./transport.ts";
 import { cloudflareWakeSchedulerLayer } from "./wake-scheduler.ts";
 
@@ -89,6 +97,12 @@ export interface CloudflareDurableRuntimeOptions {
   readonly runtimeFailpoint?:
     | ((ctx: DurableObjectState) => DurableRuntimeFailpointHandler)
     | undefined;
+  /** Conversation-maintenance generation/alarm fault injection; default none. */
+  readonly maintenanceFailpoint?:
+    | ((ctx: DurableObjectState) => ConversationMaintenanceFailpointHandler)
+    | undefined;
+  /** Host-supplied fail-closed authorization policy; defaults to service possession. */
+  readonly operationAuthorizer?: OperationAuthorizerService | undefined;
   /**
    * Reconciliation policy consulted for open ordinary Tool Calls before an Unknown Outcome
    * is recorded (durability §10, DUR-009). Defaults to the fail-closed
@@ -143,7 +157,8 @@ export type CloudflareDurableRuntimeServices =
   | ConversationObjectIdentity
   | DurableAlarmService
   | ConversationMaintenance
-  | ConversationObjectPorts;
+  | ConversationObjectPorts
+  | ProgressWaitRegistry;
 
 /**
  * Owner-side endpoint body for the Conversation Object's `portCall` (plan §1.3): decode,
@@ -340,7 +355,17 @@ export class CloudflareDurableRuntime {
           options.runtimeFailpoint === undefined
             ? DurableRuntimeFailpoint.layer
             : Layer.succeed(DurableRuntimeFailpoint)({ hit: options.runtimeFailpoint(ctx) });
+        const maintenanceFailpointLayer =
+          options.maintenanceFailpoint === undefined
+            ? ConversationMaintenanceFailpoint.layer
+            : Layer.succeed(ConversationMaintenanceFailpoint)({
+                hit: options.maintenanceFailpoint(ctx),
+              });
         const reconcilerLayer = options.toolReconciler ?? ToolReconciler.uncertain;
+        const authorizerLayer =
+          options.operationAuthorizer === undefined
+            ? Layer.empty
+            : operationAuthorizerLayer(options.operationAuthorizer);
         const bindingResolverLayer = Layer.effect(AgentBindingResolver)(
           Effect.map(
             resolveBindings(options.bindings, { ctx, env, conversationId, producerId }),
@@ -352,6 +377,8 @@ export class CloudflareDurableRuntime {
           identityLayer,
           cloudflareConfigLayer,
           DurableAlarmService.layer,
+          maintenanceFailpointLayer,
+          ProgressWaitRegistry.layer,
         );
 
         const runtimeStack = DurableAgentRuntime.layer.pipe(
@@ -360,7 +387,12 @@ export class CloudflareDurableRuntime {
           Layer.provideMerge(runtimeConfigLayer),
           Layer.provideMerge(bindingResolverLayer),
           Layer.provide(
-            Layer.mergeAll(runtimeFailpointLayer, reconcilerLayer, BrowserCrypto.layer),
+            Layer.mergeAll(
+              runtimeFailpointLayer,
+              reconcilerLayer,
+              authorizerLayer,
+              BrowserCrypto.layer,
+            ),
           ),
           Layer.provideMerge(base),
         );

package/src/progress-wait.ts

@@ -0,0 +1,103 @@
+import { Context, Deferred, Effect, Layer, Ref, type Scope } from "effect";
+
+/** Cancellation tombstones are bounded hints, never durable authority. */
+const MAX_CANCELLATION_TOMBSTONES = 1_024;
+
+type ActiveRegistration = ReadonlySet<Deferred.Deferred<void>>;
+type Registration = ActiveRegistration | "cancelled";
+type Registrations = ReadonlyMap<string, Registration>;
+
+/**
+ * Per-incarnation cancellation registry for long-lived progress RPCs. The public runtime owns
+ * the actual wake registration; this host-only registry lets an interrupted Worker Effect ask
+ * the Object to interrupt its scoped wait before the Worker execution context itself ends.
+ */
+export class ProgressWaitRegistry extends Context.Service<
+  ProgressWaitRegistry,
+  {
+    /** Register a Scope-owned cancellation signal, observing any early cancel tombstone. */
+    readonly subscribe: (
+      waiterId: string,
+    ) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;
+    /** Cancel a registered waiter, or remember a bounded early cancellation. */
+    readonly cancel: (waiterId: string) => Effect.Effect<void>;
+  }
+>()("@effect-agent/platform-cloudflare/ProgressWaitRegistry") {
+  static readonly layer: Layer.Layer<ProgressWaitRegistry> = Layer.effect(
+    ProgressWaitRegistry,
+    Effect.gen(function* () {
+      const registrations = yield* Ref.make<Registrations>(new Map());
+
+      const remove = (waiterId: string, deferred: Deferred.Deferred<void>) =>
+        Ref.update(registrations, (current) => {
+          const existing = current.get(waiterId);
+          if (existing === undefined || existing === "cancelled" || !existing.has(deferred)) {
+            return current;
+          }
+          const next = new Map(current);
+          const active = new Set(existing);
+          active.delete(deferred);
+          if (active.size === 0) {
+            next.delete(waiterId);
+          } else {
+            next.set(waiterId, active);
+          }
+          return next;
+        });
+
+      const subscribe = Effect.fn("ProgressWaitRegistry.subscribe")(
+        (waiterId: string): Effect.Effect<Effect.Effect<void>, never, Scope.Scope> =>
+          Effect.gen(function* () {
+            const deferred = yield* Deferred.make<void>();
+            yield* Effect.addFinalizer(() => remove(waiterId, deferred));
+            const cancelled = yield* Ref.modify(registrations, (current) => {
+              const existing = current.get(waiterId);
+              const next = new Map(current);
+              if (existing === "cancelled") {
+                return [true, current] as const;
+              }
+              const active = new Set(existing ?? []);
+              active.add(deferred);
+              next.set(waiterId, active);
+              return [false, next] as const;
+            });
+            return { cancelled, deferred };
+          }).pipe(
+            Effect.map(({ cancelled, deferred }) =>
+              cancelled ? Effect.void : Deferred.await(deferred),
+            ),
+          ),
+      );
+
+      const cancel = Effect.fn("ProgressWaitRegistry.cancel")(function* (waiterId: string) {
+        const waiters = yield* Ref.modify(registrations, (current) => {
+          const existing = current.get(waiterId);
+          const next = new Map(current);
+          if (existing === undefined) {
+            next.set(waiterId, "cancelled");
+            let tombstones = 0;
+            for (const registration of next.values()) {
+              if (registration === "cancelled") tombstones += 1;
+            }
+            if (tombstones > MAX_CANCELLATION_TOMBSTONES) {
+              for (const [id, registration] of next) {
+                if (registration !== "cancelled") continue;
+                next.delete(id);
+                break;
+              }
+            }
+            return [[], next] as const;
+          }
+          if (existing === "cancelled") return [[], current] as const;
+          next.delete(waiterId);
+          return [[...existing], next] as const;
+        });
+        yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, undefined), {
+          discard: true,
+        });
+      });
+
+      return ProgressWaitRegistry.of({ subscribe, cancel });
+    }),
+  );
+}

package/src/wake-scheduler.ts

@@ -1,5 +1,5 @@
 import type { ConversationId } from "@effect-agent/core";
-import { WakeScheduler } from "@effect-agent/session";
+import { makeWakeSubscriptionHub, WakeScheduler } from "@effect-agent/session";
 import { Effect, Layer, PubSub, Schema, Stream } from "effect";
 
 import { DurableAlarmService } from "./alarm.ts";
@@ -42,10 +42,12 @@ export const cloudflareWakeSchedulerLayer: Layer.Layer<
     const identity = yield* ConversationObjectIdentity;
     const { namespace } = yield* ConversationObjectNamespace;
     const hints = yield* PubSub.sliding<ConversationId>(WAKE_BUFFER_CAPACITY);
+    const progress = yield* makeWakeSubscriptionHub;
     yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
 
     const notifyLocal = (conversationId: ConversationId) =>
-      PubSub.publish(hints, conversationId).pipe(
+      progress.notify(conversationId).pipe(
+        Effect.andThen(PubSub.publish(hints, conversationId)),
         Effect.andThen(alarm.scheduleNow),
         Effect.catch((error) =>
           // `notify` never fails by contract; a failed alarm write degrades to "hint lost"
@@ -79,6 +81,7 @@ export const cloudflareWakeSchedulerLayer: Layer.Layer<
         conversationId === identity.conversationId
           ? notifyLocal(conversationId)
           : notifyRemote(conversationId),
+      subscribe: progress.subscribe,
       wakes: Stream.fromPubSub(hints),
     });
   }),