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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-agent/platform-cloudflare",
-  "version": "0.1.0-beta.15",
+  "version": "0.1.0-beta.16",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -8,10 +8,10 @@
     }
   },
   "dependencies": {
-    "@effect-agent/core": "0.1.0-beta.15",
-    "@effect-agent/sandbox": "0.1.0-beta.15",
-    "@effect-agent/session": "0.1.0-beta.15",
-    "@effect-agent/storage-cloudflare": "0.1.0-beta.15",
+    "@effect-agent/core": "0.1.0-beta.16",
+    "@effect-agent/sandbox": "0.1.0-beta.16",
+    "@effect-agent/session": "0.1.0-beta.16",
+    "@effect-agent/storage-cloudflare": "0.1.0-beta.16",
     "@effect/platform-browser": "4.0.0-beta.107",
     "@effect/sql-sqlite-do": "4.0.0-beta.107",
     "effect": "4.0.0-beta.107"

package/src/bindings.ts

@@ -31,6 +31,10 @@ export interface ConversationObjectRpc extends Rpc.DurableObjectBranded {
   submitEncoded(encoded: unknown): Promise<unknown>;
   /** Wake-hinted, poll-guaranteed settlement wait; answers an `AwaitSettlementResponse`. */
   awaitSettlementEncoded(encoded: unknown): Promise<unknown>;
+  /** Event-driven durable progress wait; answers a `ProgressObserved` host response. */
+  awaitProgressEncoded(encoded: unknown): Promise<unknown>;
+  /** Best-effort cancellation for one in-flight progress wait. */
+  cancelProgressEncoded(encoded: unknown): Promise<unknown>;
   /** One bounded page of canonical records; answers an `ObservePageResponse`. */
   observePage(encoded: unknown): Promise<unknown>;
   /** Durable abort intent; answers an `AbortResponse`. */

package/src/client.ts

@@ -18,6 +18,7 @@ import {
   IdempotencyKey,
   JoinedToHost,
   LedgerError,
+  OperationDenied,
   PersistedJson,
   Principal,
   Receipt,
@@ -29,7 +30,7 @@ import {
   type DurableSubmitAgent,
   type DurableSubmitOptions,
 } from "@effect-agent/session";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Crypto, Duration, Effect, Layer, Schema } from "effect";
 
 import { DurableAlarmError } from "./alarm.ts";
 import { ConversationObjectNamespace, type ConversationObjectRpc } from "./bindings.ts";
@@ -73,6 +74,10 @@ export class ConversationClientError extends Schema.TaggedError<ConversationClie
     conversationId: Schema.String,
     message: Schema.String,
     cause: Schema.optionalKey(Schema.Defect()),
+    /** Cloudflare's own classification for a failure safe to retry with a fresh stub. */
+    retryable: Schema.optionalKey(Schema.Boolean),
+    /** Cloudflare overloads are surfaced immediately instead of adding retry pressure. */
+    overloaded: Schema.optionalKey(Schema.Boolean),
   },
 ) {}
 
@@ -104,6 +109,21 @@ export class ObservePageRequest extends Schema.Class<ObservePageRequest>(
   limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1_024)),
 }) {}
 
+/** One event-driven wait for canonical progress strictly after this sequence. */
+export class AwaitProgressRequest extends Schema.Class<AwaitProgressRequest>(
+  "@effect-agent/platform-cloudflare/AwaitProgressRequest",
+)({
+  afterSequence: CanonicalSequence,
+  waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)),
+}) {}
+
+/** Best-effort cancellation of one in-flight progress RPC. */
+export class CancelProgressRequest extends Schema.Class<CancelProgressRequest>(
+  "@effect-agent/platform-cloudflare/CancelProgressRequest",
+)({
+  waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)),
+}) {}
+
 // ---------------------------------------------------------------------------
 // Responses
 // ---------------------------------------------------------------------------
@@ -130,6 +150,7 @@ export const HostFailure = Schema.Union([
   DurableRuntimeFailpointError,
   AdmissionLimitExceeded,
   DurableAlarmError,
+  OperationDenied,
   HostProtocolError,
 ]);
 export type HostFailure = typeof HostFailure.Type;
@@ -152,6 +173,15 @@ export class ObservedPage extends Schema.TaggedClass<ObservedPage>(
   records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1_024)),
 }) {}
 
+/** A record was already committed or an incarnation-local hint says the caller should re-read. */
+export class ProgressObserved extends Schema.TaggedClass<ProgressObserved>(
+  "@effect-agent/platform-cloudflare/ProgressObserved",
+)("ProgressObserved", {}) {}
+
+export class ProgressCancelled extends Schema.TaggedClass<ProgressCancelled>(
+  "@effect-agent/platform-cloudflare/ProgressCancelled",
+)("ProgressCancelled", {}) {}
+
 export class AbortRecorded extends Schema.TaggedClass<AbortRecorded>(
   "@effect-agent/platform-cloudflare/AbortRecorded",
 )("AbortRecorded", {
@@ -182,6 +212,8 @@ export const HostResponse = Schema.Union([
   SubmitSucceeded,
   SettlementReached,
   ObservedPage,
+  ProgressObserved,
+  ProgressCancelled,
   AbortRecorded,
   ApprovalRecorded,
   UnknownResolutionRecorded,
@@ -199,6 +231,10 @@ export const decodeReceipt = Schema.decodeUnknownEffect(Receipt);
 export const encodeReceipt = Schema.encodeEffect(Receipt);
 export const decodeObservePageRequest = Schema.decodeUnknownEffect(ObservePageRequest);
 export const encodeObservePageRequest = Schema.encodeEffect(ObservePageRequest);
+export const decodeAwaitProgressRequest = Schema.decodeUnknownEffect(AwaitProgressRequest);
+export const encodeAwaitProgressRequest = Schema.encodeEffect(AwaitProgressRequest);
+export const decodeCancelProgressRequest = Schema.decodeUnknownEffect(CancelProgressRequest);
+export const encodeCancelProgressRequest = Schema.encodeEffect(CancelProgressRequest);
 export const decodeAbortCommand = Schema.decodeUnknownEffect(AbortCommand);
 export const encodeAbortCommand = Schema.encodeEffect(AbortCommand);
 export const decodeApprovalDecisionCommand = Schema.decodeUnknownEffect(ApprovalDecisionCommand);
@@ -237,6 +273,14 @@ export type ClientAwaitFailure =
 export type ClientObserveFailure =
   | ConversationStoreError
   | ConversationNotMaterialized
+  | OperationDenied
+  | HostProtocolError
+  | ConversationClientError;
+
+export type ClientProgressFailure =
+  | ConversationStoreError
+  | ConversationNotMaterialized
+  | OperationDenied
   | HostProtocolError
   | ConversationClientError;
 
@@ -253,6 +297,7 @@ export type ClientApprovalFailure =
   | LedgerError
   | SettlementConflict
   | ApprovalConflict
+  | OperationDenied
   | DurableAlarmError
   | HostProtocolError
   | ConversationClientError;
@@ -263,6 +308,7 @@ export type ClientUnknownFailure =
   | UnknownResolutionConflict
   | JoinedToHost
   | DurableRuntimeFailpointError
+  | OperationDenied
   | DurableAlarmError
   | HostProtocolError
   | ConversationClientError;
@@ -289,8 +335,10 @@ const AWAIT_FAILURE_TAGS: ReadonlySet<string> = new Set([
 const OBSERVE_FAILURE_TAGS: ReadonlySet<string> = new Set([
   "ConversationStoreError",
   "ConversationNotMaterialized",
+  "OperationDenied",
   "HostProtocolError",
 ]);
+const PROGRESS_FAILURE_TAGS = OBSERVE_FAILURE_TAGS;
 const ABORT_FAILURE_TAGS: ReadonlySet<string> = new Set([
   "LedgerError",
   "SettlementConflict",
@@ -303,6 +351,7 @@ const APPROVAL_FAILURE_TAGS: ReadonlySet<string> = new Set([
   "LedgerError",
   "SettlementConflict",
   "ApprovalConflict",
+  "OperationDenied",
   "DurableAlarmError",
   "HostProtocolError",
 ]);
@@ -312,6 +361,7 @@ const UNKNOWN_FAILURE_TAGS: ReadonlySet<string> = new Set([
   "UnknownResolutionConflict",
   "JoinedToHost",
   "DurableRuntimeFailpointError",
+  "OperationDenied",
   "DurableAlarmError",
   "HostProtocolError",
 ]);
@@ -351,6 +401,14 @@ export class CloudflareConversationClient extends Context.Service<
     ) => Effect.Effect<Receipt, ClientSubmitFailure, InputSchema["EncodingServices"]>;
     /** Wake-hinted, poll-guaranteed settlement wait executed inside the owning Object. */
     readonly awaitSettlement: (receipt: Receipt) => Effect.Effect<Settlement, ClientAwaitFailure>;
+    /**
+     * Wait without polling until progress after `afterSequence` is already durable or hinted.
+     * The result is deliberately void: canonical records remain authoritative and must be read.
+     */
+    readonly awaitProgress: (
+      conversationId: ConversationId,
+      afterSequence: CanonicalSequence,
+    ) => Effect.Effect<void, ClientProgressFailure>;
     /** One bounded page of canonical records. */
     readonly readPage: (
       conversationId: ConversationId,
@@ -389,10 +447,37 @@ export class CloudflareConversationClient extends Context.Service<
   static readonly layer: Layer.Layer<
     CloudflareConversationClient,
     never,
-    ConversationObjectNamespace
+    ConversationObjectNamespace | Crypto.Crypto
   > = Layer.effect(CloudflareConversationClient)(
     Effect.gen(function* () {
       const { namespace } = yield* ConversationObjectNamespace;
+      const crypto = yield* Crypto.Crypto;
+
+      const platformSignals = (cause: unknown) => {
+        let retryable: boolean | undefined;
+        let overloaded: boolean | undefined;
+        if (typeof cause === "object" && cause !== null) {
+          if ("retryable" in cause && typeof cause.retryable === "boolean") {
+            retryable = cause.retryable;
+          }
+          if ("overloaded" in cause && typeof cause.overloaded === "boolean") {
+            overloaded = cause.overloaded;
+          }
+          // Miniflare's faithful `ctx.abort()` signal predates the public `retryable` field.
+          // Treat only its explicit reset marker as the same idempotent-retry classification.
+          if (
+            retryable === undefined &&
+            "durableObjectReset" in cause &&
+            cause.durableObjectReset === true
+          ) {
+            retryable = true;
+          }
+        }
+        return {
+          ...(retryable === undefined ? {} : { retryable }),
+          ...(overloaded === undefined ? {} : { overloaded }),
+        };
+      };
 
       const call = (
         conversationId: string,
@@ -410,6 +495,7 @@ export class CloudflareConversationClient extends Context.Service<
                 }`,
               ),
               cause,
+              ...platformSignals(cause),
             }),
         }).pipe(
           Effect.flatMap((raw) =>
@@ -488,6 +574,19 @@ export class CloudflareConversationClient extends Context.Service<
           return page.records;
         });
 
+      const cancelProgress = (
+        conversationId: ConversationId,
+        waiterId: string,
+      ): Effect.Effect<void> =>
+        encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(
+          Effect.mapError(() => undefined),
+          Effect.flatMap((encoded) =>
+            call(conversationId, "cancelProgress", (stub) => stub.cancelProgressEncoded(encoded)),
+          ),
+          Effect.asVoid,
+          Effect.ignore,
+        );
+
       return CloudflareConversationClient.of({
         submit: <InputSchema extends Schema.Top>(
           agent: DurableSubmitAgent<InputSchema>,
@@ -558,6 +657,55 @@ export class CloudflareConversationClient extends Context.Service<
             return settled.settlement;
           }),
 
+        awaitProgress: (conversationId, afterSequence) =>
+          Effect.gen(function* () {
+            const waiterId = yield* crypto.randomUUIDv4.pipe(
+              Effect.mapError((error) =>
+                HostProtocolError.make({
+                  message: boundHostDiagnostic(
+                    `awaitProgress cancellation identity generation failed: ${error.message}`,
+                  ),
+                }),
+              ),
+            );
+            const request = AwaitProgressRequest.make({ afterSequence, waiterId });
+            const encoded = yield* encodeAwaitProgressRequest(request).pipe(
+              Effect.mapError((error) =>
+                HostProtocolError.make({
+                  message: boundHostDiagnostic(
+                    `awaitProgress request encode failed: ${error.message}`,
+                  ),
+                }),
+              ),
+            );
+
+            const attempt = (retry: number): Effect.Effect<void, ClientProgressFailure> =>
+              call(conversationId, "awaitProgress", (stub) =>
+                stub.awaitProgressEncoded(encoded),
+              ).pipe(
+                Effect.flatMap(
+                  expect<ProgressObserved, ClientProgressFailure & HostFailure>(
+                    conversationId,
+                    "awaitProgress",
+                    "ProgressObserved",
+                    PROGRESS_FAILURE_TAGS,
+                  ),
+                ),
+                Effect.asVoid,
+                Effect.catchTag("ConversationClientError", (error) =>
+                  error.retryable === true && error.overloaded !== true && retry < 5
+                    ? Effect.sleep(Duration.millis(10 * 2 ** retry)).pipe(
+                        Effect.andThen(attempt(retry + 1)),
+                      )
+                    : Effect.fail(error),
+                ),
+              );
+
+            yield* attempt(0).pipe(
+              Effect.onInterrupt(() => cancelProgress(conversationId, waiterId)),
+            );
+          }),
+
         readPage,
 
         readAll: (conversationId) =>

package/src/conversation-object.ts

@@ -27,6 +27,7 @@ import {
   SettlementConflict,
   SubmissionLedger,
   SubmissionLookupByKey,
+  WakeScheduler,
   type DurableSubmitAgent,
 } from "@effect-agent/session";
 import type { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
@@ -56,11 +57,15 @@ import {
   HostFailed,
   HostProtocolError,
   ObservedPage,
+  ProgressObserved,
+  ProgressCancelled,
   SettlementReached,
   SubmitSucceeded,
   UnknownResolutionRecorded,
   boundHostDiagnostic,
   decodeAbortCommand,
+  decodeAwaitProgressRequest,
+  decodeCancelProgressRequest,
   decodeApprovalDecisionCommand,
   decodeObservePageRequest,
   decodeReceipt,
@@ -78,6 +83,7 @@ import {
   type CloudflareDurableRuntimeOptions,
   type CloudflareDurableRuntimeServices,
 } from "./layers.ts";
+import { ProgressWaitRegistry } from "./progress-wait.ts";
 
 /**
  * `makeConversationObjectClass(options, observability?)` — the Conversation Durable Object
@@ -279,6 +285,46 @@ const awaitSettlementEndpoint = (
     Effect.flatMap(encodeResponse),
   );
 
+const awaitProgressEndpoint = (encoded: unknown): Effect.Effect<unknown, never, EndpointServices> =>
+  decodeAwaitProgressRequest(encoded).pipe(
+    Effect.mapError(protocolFailure("The progress request could not be decoded")),
+    Effect.flatMap((request) =>
+      Effect.gen(function* () {
+        const identity = yield* ConversationObjectIdentity;
+        const runtime = yield* DurableAgentRuntime;
+        const registry = yield* ProgressWaitRegistry;
+        yield* Effect.scoped(
+          Effect.gen(function* () {
+            const cancelled = yield* registry.subscribe(request.waiterId);
+            yield* Effect.raceFirst(
+              runtime.awaitProgress(identity.conversationId, request.afterSequence),
+              cancelled,
+            );
+          }),
+        );
+        return ProgressObserved.make();
+      }),
+    ),
+    respond,
+    Effect.flatMap(encodeResponse),
+  );
+
+const cancelProgressEndpoint = (
+  encoded: unknown,
+): Effect.Effect<unknown, never, EndpointServices> =>
+  decodeCancelProgressRequest(encoded).pipe(
+    Effect.mapError(protocolFailure("The progress cancellation could not be decoded")),
+    Effect.flatMap((request) =>
+      Effect.gen(function* () {
+        const registry = yield* ProgressWaitRegistry;
+        yield* registry.cancel(request.waiterId);
+        return ProgressCancelled.make();
+      }),
+    ),
+    respond,
+    Effect.flatMap(encodeResponse),
+  );
+
 const observePageEndpoint = (encoded: unknown): Effect.Effect<unknown, never, EndpointServices> =>
   decodeObservePageRequest(encoded).pipe(
     Effect.mapError(protocolFailure("The observe request could not be decoded")),
@@ -289,14 +335,12 @@ const observePageEndpoint = (encoded: unknown): Effect.Effect<unknown, never, En
         // The same fail-closed authorization seam the runtime's `observe` consults (P7 WP1);
         // the default reference preserves the possession behavior.
         const authorizer = yield* OperationAuthorizer;
-        yield* authorizer
-          .authorize(
-            OperationAuthorizationRequest.make({
-              operation: "observe",
-              conversationId: identity.conversationId,
-            }),
-          )
-          .pipe(Effect.catchTag("OperationDenied", deniedToProtocolFailure));
+        yield* authorizer.authorize(
+          OperationAuthorizationRequest.make({
+            operation: "observe",
+            conversationId: identity.conversationId,
+          }),
+        );
         const records = yield* Stream.runCollect(
           store.read(
             ConversationRead.make({
@@ -330,24 +374,6 @@ const abortEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoint
     Effect.flatMap(encodeResponse),
   );
 
-/**
- * The pre-P7 host protocol's failure union does not carry `OperationDenied` (the Worker client
- * predates the authorizer). This assembly always runs the default possession authorizer — no
- * `CloudflareDurableRuntimeOptions` authorizer lever exists yet — so a denial here is
- * unreachable today; if one ever surfaces it degrades to the protocol failure instead of an
- * out-of-contract throw. The four P7 admin entry points below carry `OperationDenied` typed.
- */
-const deniedToProtocolFailure = (
-  denied: OperationDenied,
-): Effect.Effect<never, HostProtocolError> =>
-  Effect.fail(
-    HostProtocolError.make({
-      message: boundHostDiagnostic(
-        `The ${denied.operation} operation was denied: ${denied.reason}`,
-      ),
-    }),
-  );
-
 const resolveApprovalEndpoint = (
   encoded: unknown,
 ): Effect.Effect<unknown, never, EndpointServices> =>
@@ -357,11 +383,7 @@ const resolveApprovalEndpoint = (
       Effect.gen(function* () {
         const maintenance = yield* ConversationMaintenance;
         const runtime = yield* DurableAgentRuntime;
-        const intent = yield* maintenance.withMutation(
-          runtime
-            .resolveApproval(command)
-            .pipe(Effect.catchTag("OperationDenied", deniedToProtocolFailure)),
-        );
+        const intent = yield* maintenance.withMutation(runtime.resolveApproval(command));
         return ApprovalRecorded.make({ intent });
       }),
     ),
@@ -378,11 +400,7 @@ const resolveUnknownEndpoint = (
       Effect.gen(function* () {
         const maintenance = yield* ConversationMaintenance;
         const runtime = yield* DurableAgentRuntime;
-        const intent = yield* maintenance.withMutation(
-          runtime
-            .resolveUnknown(command)
-            .pipe(Effect.catchTag("OperationDenied", deniedToProtocolFailure)),
-        );
+        const intent = yield* maintenance.withMutation(runtime.resolveUnknown(command));
         return UnknownResolutionRecorded.make({ intent });
       }),
     ),
@@ -599,12 +617,11 @@ const portCallEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpo
   });
 
 const wakeEndpoint: Effect.Effect<void, never, EndpointServices> = Effect.gen(function* () {
-  const alarm = yield* DurableAlarmService;
-  // Wake hints are droppable by contract: a failed alarm write is logged and swallowed; the
-  // sender's own alarm/scan pairing (or this Object's next entry point) restores liveness.
-  yield* alarm.scheduleNow.pipe(
-    Effect.catch((error) => Effect.logWarning("ConversationObject.wake dropped", error)),
-  );
+  const identity = yield* ConversationObjectIdentity;
+  const wake = yield* WakeScheduler;
+  // Route the remote hint through this incarnation's scheduler so scoped progress waiters and
+  // the alarm receive the same hint. Delivery remains droppable; canonical storage is authority.
+  yield* wake.notify(identity.conversationId);
 });
 
 const alarmEndpoint: Effect.Effect<void, MaintenancePassFailure, EndpointServices> = Effect.gen(
@@ -659,6 +676,8 @@ const effectCfPlatformLayer = (
 export interface ConversationObjectInstance extends CloudflareDurableObject {
   submitEncoded(encoded: unknown): Promise<unknown>;
   awaitSettlementEncoded(encoded: unknown): Promise<unknown>;
+  awaitProgressEncoded(encoded: unknown): Promise<unknown>;
+  cancelProgressEncoded(encoded: unknown): Promise<unknown>;
   observePage(encoded: unknown): Promise<unknown>;
   abortEncoded(encoded: unknown): Promise<unknown>;
   resolveApprovalEncoded(encoded: unknown): Promise<unknown>;
@@ -727,6 +746,8 @@ export const makeConversationObjectClass = <EventLayerError = never, EventServic
   const rpc = {
     submitEncoded: (encoded: unknown) => submitEndpoint(encoded),
     awaitSettlementEncoded: (encoded: unknown) => awaitSettlementEndpoint(encoded),
+    awaitProgressEncoded: (encoded: unknown) => awaitProgressEndpoint(encoded),
+    cancelProgressEncoded: (encoded: unknown) => cancelProgressEndpoint(encoded),
     observePage: (encoded: unknown) => observePageEndpoint(encoded),
     abortEncoded: (encoded: unknown) => abortEndpoint(encoded),
     resolveApprovalEncoded: (encoded: unknown) => resolveApprovalEndpoint(encoded),

package/src/index.ts

@@ -17,6 +17,7 @@ export * from "./bindings.ts";
 export * from "./config.ts";
 export * from "./alarm.ts";
 export * from "./wake-scheduler.ts";
+export * from "./progress-wait.ts";
 export * from "./transport.ts";
 export * from "./layers.ts";
 export * from "./conversation-object.ts";

package/src/layers.ts

@@ -5,9 +5,11 @@ import {
   DurableRuntimeConfig,
   DurableRuntimeFailpoint,
   ProducerId,
+  operationAuthorizerLayer,
   ToolReconciler,
   type ConversationStore,
   type DurableRuntimeFailpointHandler,
+  type OperationAuthorizerService,
   type ResolvedBinding,
   type SubmissionLedger,
   type WakeScheduler,
@@ -45,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";
 
@@ -98,6 +101,8 @@ export interface CloudflareDurableRuntimeOptions {
   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
@@ -152,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,
@@ -356,6 +362,10 @@ export class CloudflareDurableRuntime {
                 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 }),
@@ -368,6 +378,7 @@ export class CloudflareDurableRuntime {
           cloudflareConfigLayer,
           DurableAlarmService.layer,
           maintenanceFailpointLayer,
+          ProgressWaitRegistry.layer,
         );
 
         const runtimeStack = DurableAgentRuntime.layer.pipe(
@@ -376,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 });
+    }),
+  );
+}