@effect-agent/platform-cloudflare 0.0.1-beta.5 → 0.1.0-beta.6

package/src/conversation-object.ts

@@ -29,14 +29,25 @@ import {
   SubmissionLookupByKey,
   type DurableSubmitAgent,
 } from "@effect-agent/session";
-import { DurableObject } from "cloudflare:workers";
-import { Effect, Layer, ManagedRuntime, Option, Schema, Stream } from "effect";
+import type { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
+import { Effect, Layer, Option, Schema, Stream } from "effect";
+import {
+  DurableObject as EffectCfDurableObject,
+  DurableObjectState as EffectCfDurableObjectState,
+  WorkerEnvironment,
+} from "effect-cf";
 
-import { ConversationMaintenance, DurableAlarmError, DurableAlarmService } from "./alarm.ts";
+import {
+  ConversationMaintenance,
+  DurableAlarmError,
+  DurableAlarmService,
+  type MaintenancePassFailure,
+} from "./alarm.ts";
 import {
   ConversationObjectIdentity,
   DurableObjectContext,
-  conversationNamespaceLayer,
+  ConversationObjectNamespace,
+  conversationNamespaceFromEnv,
   type CloudflareBindingError,
 } from "./bindings.ts";
 import {
@@ -69,7 +80,8 @@ import {
 } from "./layers.ts";
 
 /**
- * `makeConversationObjectClass(options)` — the Conversation Durable Object (plan §1.4,
+ * `makeConversationObjectClass(options, observability?)` — the Conversation Durable Object
+ * (plan §1.4,
  * D-P6-1): a factory returning a class that applications export from their Worker entry.
  * One SQLite-backed Object per Conversation is the serialized owner (durability §6); the
  * Object never runs `runResolvedWorker`'s infinite loop — each ingress event or alarm runs
@@ -95,9 +107,12 @@ export interface ConversationObjectOptions extends CloudflareDurableRuntimeOptio
   readonly namespaceBinding: string;
 }
 
-type ConversationObjectError = CloudflareDurableRuntimeInitializationError | CloudflareBindingError;
-
 type EndpointServices = CloudflareDurableRuntimeServices | DurableObjectContext;
+type RuntimeServices = EndpointServices | ConversationObjectNamespace;
+type ConversationObjectInitializationError =
+  | CloudflareDurableRuntimeInitializationError
+  | CloudflareBindingError
+  | MaintenancePassFailure;
 
 /** Port envelope tags whose owner-side execution durably mutates this Object's lane. */
 const MUTATING_PORT_TAGS: ReadonlySet<string> = new Set([
@@ -593,23 +608,56 @@ const wakeEndpoint: Effect.Effect<void, never, EndpointServices> = Effect.gen(fu
   );
 });
 
-const alarmEndpoint: Effect.Effect<void, unknown, EndpointServices> = Effect.gen(function* () {
-  const maintenance = yield* ConversationMaintenance;
-  // Typed pass failures propagate: the rejected promise makes workerd retry the alarm
-  // (at-least-once delivery), and the pass's own pre-arm keeps the slot committed meanwhile.
-  yield* maintenance.pass;
-});
+const alarmEndpoint: Effect.Effect<void, MaintenancePassFailure, EndpointServices> = Effect.gen(
+  function* () {
+    const maintenance = yield* ConversationMaintenance;
+    // Typed pass failures propagate: the rejected promise makes workerd retry the alarm
+    // (at-least-once delivery), and the pass's own pre-arm keeps the slot committed meanwhile.
+    yield* maintenance.pass;
+  },
+);
 
-const gateEndpoint: Effect.Effect<void, unknown, EndpointServices> = Effect.gen(function* () {
-  // Forcing ConversationMaintenance forces the whole Layer stack: migration + exact-version
-  // check + configuration decode (DEPLOY-008 fails typed here, before any mutation), then
-  // the defensive local ensure-alarm half of the invariant. LOCAL-ONLY by construction.
-  const maintenance = yield* ConversationMaintenance;
-  yield* maintenance.ensureAlarm;
-});
+const gateEndpoint: Effect.Effect<void, MaintenancePassFailure, EndpointServices> = Effect.gen(
+  function* () {
+    // Forcing ConversationMaintenance forces the whole Layer stack: migration + exact-version
+    // check + configuration decode (DEPLOY-008 fails typed here, before any mutation), then
+    // the defensive local ensure-alarm half of the invariant. LOCAL-ONLY by construction.
+    const maintenance = yield* ConversationMaintenance;
+    yield* maintenance.ensureAlarm;
+  },
+);
+
+/**
+ * Adapter from effect-cf's native Durable Object services to Effect Agent's existing platform
+ * ports. effect-cf owns the cached ManagedRuntime and supplies these values once per Object
+ * incarnation; the durable runtime continues to depend only on the narrow services below.
+ */
+const effectCfPlatformLayer = (
+  namespaceBinding: string,
+): Layer.Layer<
+  DurableObjectContext | ConversationObjectNamespace,
+  CloudflareBindingError,
+  EffectCfDurableObjectState.DurableObjectState | WorkerEnvironment
+> => {
+  const context = Layer.effect(DurableObjectContext)(
+    Effect.gen(function* () {
+      const state = yield* EffectCfDurableObjectState.DurableObjectState;
+      const env = yield* WorkerEnvironment;
+      return DurableObjectContext.of({ ctx: state.raw, env });
+    }),
+  );
+  const namespace = Layer.effect(ConversationObjectNamespace)(
+    Effect.gen(function* () {
+      const env = yield* WorkerEnvironment;
+      const binding = yield* conversationNamespaceFromEnv(env, namespaceBinding);
+      return ConversationObjectNamespace.of({ namespace: binding });
+    }),
+  );
+  return Layer.merge(context, namespace);
+};
 
 /** The public endpoint surface of one Conversation Object instance. */
-export interface ConversationObjectInstance extends DurableObject {
+export interface ConversationObjectInstance extends CloudflareDurableObject {
   submitEncoded(encoded: unknown): Promise<unknown>;
   awaitSettlementEncoded(encoded: unknown): Promise<unknown>;
   observePage(encoded: unknown): Promise<unknown>;
@@ -622,7 +670,7 @@ export interface ConversationObjectInstance extends DurableObject {
   obligationsEncoded(encoded: unknown): Promise<unknown>;
   portCall(encoded: unknown): Promise<unknown>;
   wake(): Promise<void>;
-  alarm(): Promise<void>;
+  alarm(alarmInfo?: AlarmInvocationInfo): Promise<void> | void;
 }
 
 /** The constructor shape workerd instantiates for each Conversation Object. */
@@ -631,84 +679,88 @@ export interface ConversationObjectClass {
 }
 
 /**
- * Build the application's Conversation Object class (export it from the
- * Worker entry). The explicit return type is what makes declaration emit
- * possible: the class body carries a private runtime field, and TS4094
- * rejects inferring an exported anonymous class type around it.
+ * Build the application's Conversation Object class (export it from the Worker entry).
+ * effect-cf owns the cached ManagedRuntime, native RPC methods, event scopes, and post-handler
+ * OTLP flush scheduling for RPC and alarm events. The optional outer Layer is built per native
+ * event, so a host can install Tracer/Logger/Metric services and `OtlpExporter.Flusher` without
+ * Effect Agent owning exporter lifecycle machinery.
  */
-export const makeConversationObjectClass = (
+export const makeConversationObjectClass = <EventLayerError = never, EventServices = never>(
   options: ConversationObjectOptions,
+  observability?: Layer.Layer<
+    EventServices,
+    EventLayerError,
+    | DurableObjectContext
+    | ConversationObjectNamespace
+    | EffectCfDurableObjectState.DurableObjectState
+    | WorkerEnvironment
+  >,
 ): ConversationObjectClass => {
-  class ConversationObject extends DurableObject {
-    readonly #runtime: ManagedRuntime.ManagedRuntime<EndpointServices, ConversationObjectError>;
-
-    constructor(ctx: DurableObjectState, env: Cloudflare.Env) {
-      super(ctx, env);
-      this.#runtime = ManagedRuntime.make(
-        CloudflareDurableRuntime.layer(options).pipe(
-          Layer.provideMerge(
-            Layer.mergeAll(
-              DurableObjectContext.layer(ctx, env),
-              conversationNamespaceLayer(env, options.namespaceBinding),
-            ),
-          ),
-        ),
-      );
-      // The constructor gate: local-only checks; never the recovery pass (deadlock argument,
-      // plan §1.4). A failure here fails every delivery with the typed construction error.
-      ctx.blockConcurrencyWhile(() => this.#runtime.runPromise(gateEndpoint));
-    }
-
-    async submitEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(submitEndpoint(encoded));
-    }
-
-    async awaitSettlementEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(awaitSettlementEndpoint(encoded));
-    }
-
-    async observePage(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(observePageEndpoint(encoded));
-    }
-
-    async abortEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(abortEndpoint(encoded));
-    }
-
-    async resolveApprovalEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(resolveApprovalEndpoint(encoded));
-    }
-
-    async resolveUnknownEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(resolveUnknownEndpoint(encoded));
-    }
-
-    async explainEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(explainEndpoint(encoded));
-    }
-
-    async verifyEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(verifyEndpoint(encoded));
-    }
-
-    async retryEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(retryEndpoint(encoded));
-    }
-
-    async obligationsEncoded(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(obligationsEndpoint(encoded));
-    }
+  const application: Layer.Layer<
+    RuntimeServices,
+    CloudflareDurableRuntimeInitializationError | CloudflareBindingError,
+    EffectCfDurableObjectState.DurableObjectState | WorkerEnvironment
+  > = CloudflareDurableRuntime.layer(options).pipe(
+    Layer.provideMerge(effectCfPlatformLayer(options.namespaceBinding)),
+  );
 
-    async portCall(encoded: unknown): Promise<unknown> {
-      return this.#runtime.runPromise(portCallEndpoint(encoded));
-    }
+  // The storage/config Layer must acquire inside Cloudflare's constructor gate. effect-cf owns
+  // the ManagedRuntime, while this effectContext ensures its first Layer build enters the gate
+  // before migration, compatibility checks, or alarm inspection touch Object storage.
+  const runtime: Layer.Layer<
+    RuntimeServices,
+    ConversationObjectInitializationError,
+    EffectCfDurableObjectState.DurableObjectState | WorkerEnvironment
+  > = Layer.effectContext(
+    Effect.gen(function* () {
+      const state = yield* EffectCfDurableObjectState.DurableObjectState;
+      const scope = yield* Effect.scope;
+      return yield* state.blockConcurrencyWhile(
+        Effect.gen(function* () {
+          const services = yield* Layer.buildWithScope(application, scope);
+          yield* gateEndpoint.pipe(Effect.provide(services));
+          return services;
+        }),
+      );
+    }),
+  );
 
-    async wake(): Promise<void> {
-      await this.#runtime.runPromise(wakeEndpoint);
-    }
+  const rpc = {
+    submitEncoded: (encoded: unknown) => submitEndpoint(encoded),
+    awaitSettlementEncoded: (encoded: unknown) => awaitSettlementEndpoint(encoded),
+    observePage: (encoded: unknown) => observePageEndpoint(encoded),
+    abortEncoded: (encoded: unknown) => abortEndpoint(encoded),
+    resolveApprovalEncoded: (encoded: unknown) => resolveApprovalEndpoint(encoded),
+    resolveUnknownEncoded: (encoded: unknown) => resolveUnknownEndpoint(encoded),
+    explainEncoded: (encoded: unknown) => explainEndpoint(encoded),
+    verifyEncoded: (encoded: unknown) => verifyEndpoint(encoded),
+    retryEncoded: (encoded: unknown) => retryEndpoint(encoded),
+    obligationsEncoded: (encoded: unknown) => obligationsEndpoint(encoded),
+    portCall: (encoded: unknown) => portCallEndpoint(encoded),
+    wake: () => wakeEndpoint,
+  } satisfies EffectCfDurableObject.DurableObjectRpc<RuntimeServices | EventServices>;
+
+  const EffectCfConversationObject = EffectCfDurableObject.make<
+    RuntimeServices,
+    ConversationObjectInitializationError,
+    EventServices,
+    EventLayerError,
+    typeof rpc
+  >(runtime, {
+    ...(observability === undefined ? {} : { eventLayer: observability }),
+    // Force the gated runtime Layer when Cloudflare loads this Object incarnation. Recovery stays
+    // in each bounded pass so cross-Object initialization cannot deadlock.
+    initialize: Effect.void,
+    rpc,
+    alarm: () => alarmEndpoint,
+  });
 
-    override async alarm(): Promise<void> {
-      await this.#runtime.runPromise(alarmEndpoint);
+  // effect-cf's class type keeps `alarm` optional even when the handler option is present. This
+  // concrete override reflects this factory's stronger contract while delegating execution to
+  // the effect-cf runtime unchanged.
+  class ConversationObject extends EffectCfConversationObject {
+    override alarm(alarmInfo?: AlarmInvocationInfo): Promise<void> | void {
+      return super.alarm?.(alarmInfo);
     }
   }
 

package/src/index.ts

@@ -20,3 +20,4 @@ export * from "./transport.ts";
 export * from "./layers.ts";
 export * from "./conversation-object.ts";
 export * from "./client.ts";
+export * from "./code-mode-executor.ts";