@effect-agent/platform-cloudflare 0.1.0-beta.37 → 0.1.0-beta.39

package/src/layers.ts

@@ -1,4 +1,4 @@
-import { ConversationId } from "@effect-agent/core";
+import { ThreadId } from "@effect-agent/core";
 import type {
   RunContextPreparation,
   RunCostEstimator,
@@ -7,27 +7,13 @@ import type {
 import {
   CurrentToolFailureObserver,
   RunContextPreparationPassthrough,
+  RunToolAuthorization,
   toolFailureObserverLayer,
 } from "@effect-agent/engine";
 import {
-  AgentBindingResolver,
-  DurableAgentRuntime,
-  DurableRuntimeConfig,
-  DurableRuntimeFailpoint,
-  ProducerId,
-  operationAuthorizerLayer,
-  ToolReconciler,
-  type ConversationStore,
-  type DurableRuntimeFailpointHandler,
-  type OperationAuthorizerService,
-  type ResolvedBinding,
-  type SubmissionLedger,
-  type WakeScheduler,
-} from "@effect-agent/session";
-import {
-  conversationStoreLayer,
+  threadStoreLayer,
   executePortRequest,
-  routedConversationStoreLayer,
+  routedThreadStoreLayer,
   routedSubmissionLedgerLayer,
   storageConfigLayer,
   storageFailpointLayer,
@@ -35,24 +21,42 @@ import {
   type DoStorageFailpointHandler,
   type DoStorageInitializationError,
   type DoStorageOptions,
+  type DoStorageFailpoint,
   type PortRequest,
   type PortResponse,
 } from "@effect-agent/storage-cloudflare";
+import {
+  compileRegistrations,
+  DurableAgentRuntime,
+  DurableRuntimeConfig,
+  DurableRuntimeFailpoint,
+  ProducerId,
+  operationAuthorizerLayer,
+  ToolReconciler,
+  type AgentRegistration,
+  type ThreadStore,
+  type DigestError,
+  type DurableRuntimeFailpointHandler,
+  type OperationAuthorizerService,
+  type ResolvedBinding,
+  type SubmissionLedger,
+  type WakeScheduler,
+} from "@effect-agent/thread";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
 import type { Crypto } from "effect";
 import { Context, Duration, Effect, Layer, Schema } from "effect";
 
 import {
-  ConversationMaintenance,
-  ConversationMaintenanceFailpoint,
+  ThreadMaintenance,
+  ThreadMaintenanceFailpoint,
   DurableAlarmService,
-  type ConversationMaintenanceFailpointHandler,
+  type ThreadMaintenanceFailpointHandler,
 } from "./alarm.ts";
 import {
-  ConversationObjectIdentity,
+  ThreadObjectIdentity,
   DurableObjectContext,
-  type ConversationObjectNamespace,
+  type ThreadObjectNamespace,
 } from "./bindings.ts";
 import {
   CLOUDFLARE_RUNTIME_DEFAULTS,
@@ -61,18 +65,18 @@ import {
   CloudflarePlatformConfigError,
 } from "./config.ts";
 import { ProgressWaitRegistry } from "./progress-wait.ts";
-import { conversationPortTransportLayer } from "./transport.ts";
+import { threadPortTransportLayer } from "./transport.ts";
 import { cloudflareWakeSchedulerLayer } from "./wake-scheduler.ts";
 
 /**
- * Raw (unvalidated) construction options for `CloudflareDurableRuntime.layer`, mirroring
+ * Raw (unvalidated) construction options for `ThreadObject.make`, mirroring
  * `NodeDurableRuntimeOptions`. Optional fields default to the documented production values
  * (`CLOUDFLARE_RUNTIME_DEFAULTS`); everything is schema-decoded into
  * `CloudflareDurableRuntimeConfigValue` before any resource opens (deployment §5 gate 1).
  */
 export interface CloudflareDurableRuntimeOptions {
   readonly deploymentId: string;
-  /** Head of the minted producer identity `{producerPrefix}:{conversationId}`. */
+  /** Head of the minted producer identity `{producerPrefix}:{threadId}`. */
   readonly producerPrefix: string;
   /** Milliseconds; default 30s (D5). */
   readonly ownershipLeaseDuration?: number | undefined;
@@ -114,9 +118,9 @@ export interface CloudflareDurableRuntimeOptions {
   readonly runtimeFailpoint?:
     | ((ctx: DurableObjectState) => DurableRuntimeFailpointHandler)
     | undefined;
-  /** Conversation-maintenance generation/alarm fault injection; default none. */
+  /** Thread-maintenance generation/alarm fault injection; default none. */
   readonly maintenanceFailpoint?:
-    | ((ctx: DurableObjectState) => ConversationMaintenanceFailpointHandler)
+    | ((ctx: DurableObjectState) => ThreadMaintenanceFailpointHandler)
     | undefined;
   /** Host-supplied fail-closed authorization policy; defaults to service possession. */
   readonly operationAuthorizer?: OperationAuthorizerService | undefined;
@@ -126,65 +130,36 @@ export interface CloudflareDurableRuntimeOptions {
    * `ToolReconciler.uncertain`.
    */
   readonly toolReconciler?: Layer.Layer<ToolReconciler> | undefined;
-  /**
-   * Registered worker Bindings resolved at durable claim time:
-   * build each with `DurableWorkerBinding.make(binding, digests)`. The callback receives the live
-   * Object context and derived identities and is evaluated once per incarnation during Layer
-   * construction. Defaults to the empty registration (every resolved claim fails closed).
-   */
-  readonly bindings?: CloudflareBindingSource | undefined;
-  /**
-   * Generic Run context acquired with this Durable Object incarnation. It may prepare model
-   * context and/or authorize exact model-declared application Tool Calls at action time. The
-   * Layer may depend
-   * only on `Crypto.Crypto`, which this platform supplies with `BrowserCrypto`; hosts must close
-   * every application-specific service before passing it here. Default absent.
-   */
-  readonly runContext?: CloudflareRunContextSource | undefined;
-}
-
-/** Per-incarnation host values available to Effect-native runtime extension factories. */
-export interface CloudflareRuntimeSourceContext {
-  readonly ctx: DurableObjectState;
-  readonly env: unknown;
-  readonly conversationId: ConversationId;
-  readonly producerId: ProducerId;
 }
 
-/** Per-incarnation host values available while registered worker Bindings are captured. */
-export interface CloudflareBindingSourceContext extends CloudflareRuntimeSourceContext {}
-
-/** Captures registered worker Bindings once for each Durable Object incarnation. */
-export type CloudflareBindingSource = (
-  context: CloudflareBindingSourceContext,
-) => Effect.Effect<ReadonlyArray<ResolvedBinding>, never, never>;
-
-/** A closed Run-context service whose only remaining requirement is platform Crypto. */
-export type CloudflareRunContextLayer = Layer.Layer<RunContextPreparation, never, Crypto.Crypto>;
-
-/** One Layer or a per-incarnation factory over explicit Cloudflare host values. */
-export type CloudflareRunContextSource =
-  | CloudflareRunContextLayer
-  | ((context: CloudflareRuntimeSourceContext) => CloudflareRunContextLayer);
+/** Services supplied before the application graph is built, including its dependencies. */
+export type CloudflareBootstrapServices =
+  | CloudflareDurableRuntimeConfig
+  | ThreadObjectIdentity
+  | DurableRuntimeConfig
+  | Crypto.Crypto
+  | DoStorageFailpoint
+  | DurableRuntimeFailpoint
+  | ThreadMaintenanceFailpoint
+  | RunContextPreparation
+  | RunToolAuthorization
+  | ToolReconciler;
 
 /** Every construction failure of the assembled Cloudflare durable runtime stack. */
 export type CloudflareDurableRuntimeInitializationError =
   | CloudflarePlatformConfigError
+  | DigestError
   | DoStorageInitializationError;
 
-/** The services `CloudflareDurableRuntime.layer` provides. */
+/** The services `ThreadObject.layer` provides. */
 export type CloudflareDurableRuntimeServices =
   | DurableAgentRuntime
   | SubmissionLedger
-  | ConversationStore
+  | ThreadStore
   | WakeScheduler
-  | DurableRuntimeConfig
-  | AgentBindingResolver
-  | CloudflareDurableRuntimeConfig
-  | ConversationObjectIdentity
   | DurableAlarmService
-  | ConversationMaintenance
-  | ConversationObjectPorts
+  | ThreadMaintenance
+  | ThreadObjectPorts
   | ProgressWaitRegistry;
 
 /**
@@ -193,15 +168,15 @@ export type CloudflareDurableRuntimeServices =
  * request cannot bounce between Objects — and returns the typed response for the endpoint to
  * encode.
  */
-export class ConversationObjectPorts extends Context.Service<
-  ConversationObjectPorts,
+export class ThreadObjectPorts extends Context.Service<
+  ThreadObjectPorts,
   {
     readonly handle: (request: PortRequest) => Effect.Effect<PortResponse>;
   }
->()("@effect-agent/platform-cloudflare/ConversationObjectPorts") {}
+>()("@effect-agent/platform-cloudflare/ThreadObjectPorts") {}
 
 const decodeConfigValue = Schema.decodeUnknownEffect(CloudflareDurableRuntimeConfigValue);
-const decodeConversationId = Schema.decodeUnknownEffect(ConversationId);
+const decodeThreadId = Schema.decodeUnknownEffect(ThreadId);
 const decodeProducerId = Schema.decodeUnknownEffect(ProducerId);
 
 const configFromOptions = (
@@ -244,203 +219,149 @@ const configFromOptions = (
   );
 
 /**
- * The Conversation this Object owns, from the Object identity rule (plan §1.2): Conversation
- * Objects are addressed exclusively by `idFromName(conversationId)`, so `ctx.id.name` IS the
- * Conversation ID. An unnamed Object (from `newUniqueId`) is a deployment error, not a lane.
+ * The Thread this Object owns, from the Object identity rule (plan §1.2): Thread
+ * Objects are addressed exclusively by `idFromName(threadId)`, so `ctx.id.name` IS the
+ * Thread ID. An unnamed Object (from `newUniqueId`) is a deployment error, not a lane.
  */
-const conversationIdFromState = (
+const threadIdFromState = (
   ctx: DurableObjectState,
-): Effect.Effect<ConversationId, CloudflarePlatformConfigError> =>
+): Effect.Effect<ThreadId, CloudflarePlatformConfigError> =>
   ctx.id.name === undefined
     ? Effect.fail(
         CloudflarePlatformConfigError.make({
           message:
-            "This Durable Object was not created via idFromName(conversationId); Conversation " +
-            "Objects must be addressed by their Conversation identity (plan §1.2).",
+            "This Durable Object was not created via idFromName(threadId); Thread " +
+            "Objects must be addressed by their Thread identity (plan §1.2).",
         }),
       )
-    : decodeConversationId(ctx.id.name).pipe(
+    : decodeThreadId(ctx.id.name).pipe(
         Effect.mapError((error) =>
           CloudflarePlatformConfigError.make({
-            message: `The Durable Object name is not a valid ConversationId: ${error.message}`,
+            message: `The Durable Object name is not a valid ThreadId: ${error.message}`,
             cause: error,
           }),
         ),
       );
 
-const resolveBindings = (
-  source: CloudflareDurableRuntimeOptions["bindings"],
-  context: CloudflareBindingSourceContext,
-): Effect.Effect<ReadonlyArray<ResolvedBinding>> =>
-  source === undefined ? Effect.succeed([]) : Effect.suspend(() => source(context));
-
-const resolveRunContext = (
-  source: CloudflareRunContextSource,
-  context: CloudflareRuntimeSourceContext,
-): CloudflareRunContextLayer => (typeof source === "function" ? source(context) : source);
-
 /**
- * The DC Layer assembly (deployment §12: a Layer-assembly library, not an app entrypoint;
- * plan §1.4). `layer(options)` decodes the configuration, derives this Object's Conversation
- * and producer identities, opens the Object's private SQLite database through
- * `@effect/sql-sqlite-do` for BOTH the Conversation Log and the Submission Ledger (so claims
- * fence the same producer epochs — ADR-0011 D7 transposed), wraps the local port facets with
- * the WP2 cross-Object routing decorators over the Durable Object RPC transport, wires the
- * alarm-backed wake scheduler and the maintenance pass, defaults reconciliation to the
- * fail-closed `ToolReconciler.uncertain`, and provides a ready `DurableAgentRuntime` on top.
- *
- * Storage compatibility is verified during construction: an incompatible database fails the
- * Layer typed (`DoStorageCompatibilityError`) before anything is mutated (DEPLOY-008).
- *
- * Requires only the two binding services (`DurableObjectContext`,
- * `ConversationObjectNamespace`) — platform values enter exclusively through Layers
- * (DEPLOY-010).
+ * Validate deployment settings and derive services before building application dependencies.
+ * The native class factory builds this Layer inside its constructor gate. Custom Effect hosts
+ * can provide it around the complete application Layer with the native context already supplied.
  */
-export class CloudflareDurableRuntime {
-  static layer(
-    options: CloudflareDurableRuntimeOptions,
-  ): Layer.Layer<
-    CloudflareDurableRuntimeServices,
-    CloudflareDurableRuntimeInitializationError,
-    DurableObjectContext | ConversationObjectNamespace
-  > {
-    return Layer.unwrap(
-      Effect.gen(function* () {
-        const { ctx, env } = yield* DurableObjectContext;
-        const config = yield* configFromOptions(options);
-        const conversationId = yield* conversationIdFromState(ctx);
-        const producerId = yield* decodeProducerId(
-          `${config.producerPrefix}:${conversationId}`,
-        ).pipe(
-          Effect.mapError((error) =>
-            CloudflarePlatformConfigError.make({
-              message: `The minted producer identity is invalid: ${error.message}`,
-              cause: error,
-            }),
-          ),
-        );
-
-        const identityLayer = Layer.succeed(ConversationObjectIdentity)({
-          conversationId,
-          producerId,
-        });
-        const cloudflareConfigLayer = Layer.succeed(CloudflareDurableRuntimeConfig)(config);
-
-        const storageOptions: DoStorageOptions = {
-          storage: ctx.storage,
-          observationPollInterval: config.observationPollInterval,
-          ownershipLeaseDuration: config.ownershipLeaseDuration,
-          maxStoredValueBytes: config.maxStoredValueBytes,
-          verifyOnOpen: config.verifyOnOpen,
-          failpoint: options.storageFailpoint?.(ctx),
-        };
-        const infrastructure = Layer.mergeAll(
-          storageConfigLayer(storageOptions),
-          storageFailpointLayer(storageOptions),
-          SqliteClient.layer({ storage: ctx.storage }),
-          BrowserCrypto.layer,
-        );
-
-        /**
-         * ONE local-facet instance (a shared Layer value) serves both the routed decorators
-         * and the owner-side `portCall` executor — the executor must never see the routed
-         * ports (plan §1.3: re-routing could bounce a request between Objects).
-         */
-        const localPorts = Layer.mergeAll(conversationStoreLayer, submissionLedgerLayer).pipe(
-          Layer.provide(infrastructure),
-        );
-
-        const portsEndpointLayer = Layer.effect(ConversationObjectPorts)(
-          Effect.gen(function* () {
-            const local = yield* Effect.context<SubmissionLedger | ConversationStore>();
-            return ConversationObjectPorts.of({
-              handle: (request) => executePortRequest(request).pipe(Effect.provide(local)),
-            });
-          }),
-        ).pipe(Layer.provide(localPorts));
-
-        const routedPorts = Layer.mergeAll(
-          routedSubmissionLedgerLayer({ localConversationId: conversationId }),
-          routedConversationStoreLayer({ localConversationId: conversationId }),
-        ).pipe(Layer.provide(localPorts), Layer.provide(conversationPortTransportLayer));
-
-        const runtimeConfigLayer = Layer.succeed(DurableRuntimeConfig)(
-          DurableRuntimeConfig.make({
-            deploymentId: config.deploymentId,
-            producerId,
-            settlementPollInterval: Duration.millis(config.settlementPollInterval),
-            leaseRenewalInterval: Duration.millis(config.leaseRenewalInterval),
-            abortPollInterval: Duration.millis(config.abortPollInterval),
-            ...(options.estimateCostMicrousd === undefined
-              ? {}
-              : { estimateCostMicrousd: options.estimateCostMicrousd }),
+export const layerConfig = (
+  options: CloudflareDurableRuntimeOptions,
+): Layer.Layer<CloudflareBootstrapServices, CloudflarePlatformConfigError, DurableObjectContext> =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      const { ctx } = yield* DurableObjectContext;
+      const config = yield* configFromOptions(options);
+      const threadId = yield* threadIdFromState(ctx);
+      const producerId = yield* decodeProducerId(`${config.producerPrefix}:${threadId}`).pipe(
+        Effect.mapError((error) =>
+          CloudflarePlatformConfigError.make({
+            message: `The minted producer identity is invalid: ${error.message}`,
+            cause: error,
           }),
-        );
-
-        const runtimeFailpointLayer =
-          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 observerLayer =
-          options.toolFailureObserver === undefined
-            ? Layer.succeed(CurrentToolFailureObserver)(undefined)
-            : toolFailureObserverLayer(options.toolFailureObserver);
-        const bindingResolverLayer = Layer.effect(AgentBindingResolver)(
-          Effect.map(
-            resolveBindings(options.bindings, { ctx, env, conversationId, producerId }),
-            (bindings) => AgentBindingResolver.fromBindings(bindings),
-          ),
-        );
-        const runContextLayer =
-          options.runContext === undefined
-            ? RunContextPreparationPassthrough
-            : resolveRunContext(options.runContext, { ctx, env, conversationId, producerId }).pipe(
-                Layer.provide(BrowserCrypto.layer),
-              );
+        ),
+      );
+      return Layer.mergeAll(
+        Layer.succeed(CloudflareDurableRuntimeConfig, config),
+        Layer.succeed(ThreadObjectIdentity, { threadId, producerId }),
+        DurableRuntimeConfig.layer({
+          deploymentId: config.deploymentId,
+          producerId,
+          settlementPollInterval: Duration.millis(config.settlementPollInterval),
+          leaseRenewalInterval: Duration.millis(config.leaseRenewalInterval),
+          abortPollInterval: Duration.millis(config.abortPollInterval),
+          ...(options.estimateCostMicrousd === undefined
+            ? {}
+            : { estimateCostMicrousd: options.estimateCostMicrousd }),
+        }),
+        BrowserCrypto.layer,
+        storageFailpointLayer({ storage: ctx.storage, failpoint: options.storageFailpoint?.(ctx) }),
+        options.runtimeFailpoint === undefined
+          ? DurableRuntimeFailpoint.layer
+          : Layer.succeed(DurableRuntimeFailpoint, { hit: options.runtimeFailpoint(ctx) }),
+        options.maintenanceFailpoint === undefined
+          ? ThreadMaintenanceFailpoint.layer
+          : Layer.succeed(ThreadMaintenanceFailpoint, {
+              hit: options.maintenanceFailpoint(ctx),
+            }),
+        options.toolReconciler ?? ToolReconciler.uncertain,
+        options.operationAuthorizer === undefined
+          ? Layer.empty
+          : operationAuthorizerLayer(options.operationAuthorizer),
+        options.toolFailureObserver === undefined
+          ? Layer.succeed(CurrentToolFailureObserver, undefined)
+          : toolFailureObserverLayer(options.toolFailureObserver),
+        RunContextPreparationPassthrough,
+        RunToolAuthorization.allowAll,
+      );
+    }),
+  );
 
-        const base = Layer.mergeAll(
-          identityLayer,
-          cloudflareConfigLayer,
-          DurableAlarmService.layer,
-          maintenanceFailpointLayer,
-          ProgressWaitRegistry.layer,
-        );
+/**
+ * Register typed Agents and version declarations. Hashing and dependency capture happen in
+ * this Layer's Scope, after application Layers have been provided. Every Agent's instruction,
+ * Tool, Schema, and model requirements remain visible until satisfied by Layer composition.
+ * Use Layer.unwrap for registration values that need effectful application setup.
+ */
+export const layer = <const Entries extends ReadonlyArray<AgentRegistration>>(
+  registrations: Entries,
+) => Layer.unwrap(Effect.map(compileRegistrations(registrations), layerFromBindings));
 
-        const runtimeStack = DurableAgentRuntime.layerWithContext.pipe(
-          Layer.provideMerge(routedPorts),
-          Layer.provideMerge(cloudflareWakeSchedulerLayer),
-          Layer.provideMerge(runtimeConfigLayer),
-          Layer.provideMerge(bindingResolverLayer),
-          Layer.provide(
-            Layer.mergeAll(
-              runtimeFailpointLayer,
-              reconcilerLayer,
-              authorizerLayer,
-              observerLayer,
-              runContextLayer,
-              BrowserCrypto.layer,
-            ),
-          ),
-          Layer.provideMerge(base),
-        );
+/** Internal assembly shared by registration compilation and low-level adapter fixtures. */
+export const layerFromBindings = (
+  bindings: ReadonlyArray<ResolvedBinding>,
+): Layer.Layer<
+  CloudflareDurableRuntimeServices,
+  DoStorageInitializationError,
+  DurableObjectContext | ThreadObjectNamespace | CloudflareBootstrapServices
+> =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      const { ctx } = yield* DurableObjectContext;
+      const config = yield* CloudflareDurableRuntimeConfig;
+      const { threadId } = yield* ThreadObjectIdentity;
+      const storageOptions: DoStorageOptions = {
+        storage: ctx.storage,
+        observationPollInterval: config.observationPollInterval,
+        ownershipLeaseDuration: config.ownershipLeaseDuration,
+        maxStoredValueBytes: config.maxStoredValueBytes,
+        verifyOnOpen: config.verifyOnOpen,
+      };
+      const infrastructure = Layer.mergeAll(
+        storageConfigLayer(storageOptions),
+        SqliteClient.layer({ storage: ctx.storage }),
+      );
 
-        return Layer.mergeAll(
-          runtimeStack,
-          ConversationMaintenance.layer.pipe(Layer.provide(runtimeStack)),
-          portsEndpointLayer,
-        );
-      }),
-    );
-  }
-}
+      // The same local ports serve routed decorators and owner-side RPC execution.
+      // The RPC executor must never receive routed ports and bounce requests between Objects.
+      const localPorts = Layer.mergeAll(threadStoreLayer, submissionLedgerLayer).pipe(
+        Layer.provide(infrastructure),
+      );
+      const portsEndpointLayer = Layer.effect(ThreadObjectPorts)(
+        Effect.gen(function* () {
+          const local = yield* Effect.context<SubmissionLedger | ThreadStore>();
+          return ThreadObjectPorts.of({
+            handle: (request) => executePortRequest(request).pipe(Effect.provide(local)),
+          });
+        }),
+      ).pipe(Layer.provide(localPorts));
+      const routedPorts = Layer.mergeAll(
+        routedSubmissionLedgerLayer({ localThreadId: threadId }),
+        routedThreadStoreLayer({ localThreadId: threadId }),
+      ).pipe(Layer.provide(localPorts), Layer.provide(threadPortTransportLayer));
+      const base = Layer.mergeAll(DurableAlarmService.layer, ProgressWaitRegistry.layer);
+      const runtimeStack = DurableAgentRuntime.layerWithServices.pipe(
+        Layer.provideMerge(routedPorts),
+        Layer.provideMerge(cloudflareWakeSchedulerLayer),
+        Layer.provideMerge(base),
+      );
+      return Layer.mergeAll(
+        runtimeStack,
+        ThreadMaintenance.layer(bindings).pipe(Layer.provide(runtimeStack)),
+        portsEndpointLayer,
+      );
+    }),
+  );

package/src/prepared-admission.ts

@@ -0,0 +1,90 @@
+import type { AgentId } from "@effect-agent/core";
+import {
+  type DurableSubmitAgent,
+  PersistedJson,
+  type PreparedInput,
+  PreparedInputAdmission,
+  type ScheduledEnvelope,
+  ScheduledInputAdmission,
+  ScheduledInputRetryable,
+  ScheduleStorageError,
+} from "@effect-agent/thread";
+import { Effect, Layer } from "effect";
+
+import { CloudflareThreadClient, type ThreadClientError } from "./client.ts";
+
+const passthroughAgent = (agentId: AgentId): DurableSubmitAgent<typeof PersistedJson> => ({
+  definition: { id: agentId, input: PersistedJson },
+});
+
+/** Ordinary prepared admission through one freshly addressed Thread Object call. */
+export const cloudflarePreparedInputAdmissionLayer: Layer.Layer<
+  PreparedInputAdmission,
+  never,
+  CloudflareThreadClient
+> = Layer.effect(
+  PreparedInputAdmission,
+  Effect.gen(function* () {
+    const client = yield* CloudflareThreadClient;
+    return PreparedInputAdmission.of({
+      submit: (envelope) =>
+        client
+          .submit(passthroughAgent(envelope.agentId), envelope.input, {
+            threadId: envelope.threadId,
+            principal: envelope.deliveryPrincipal,
+            idempotencyKey: envelope.admissionKey,
+            definitions: envelope.definitions,
+          })
+          .pipe(
+            Effect.catchTags({
+              AdmissionConflict: () =>
+                ScheduleStorageError.make({ operation: "prepared admission", reason: "corrupt" }),
+              AdmissionLimitExceeded: () => ScheduledInputRetryable.make({ reason: "capacity" }),
+              ThreadClientError: (error: ThreadClientError) =>
+                ScheduledInputRetryable.make({
+                  reason: error.overloaded === true ? "capacity" : "transport",
+                }),
+              HostProtocolError: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
+              LedgerError: () => ScheduledInputRetryable.make({ reason: "storage" }),
+              ThreadStoreError: () => ScheduledInputRetryable.make({ reason: "storage" }),
+              DurableAlarmError: () => ScheduledInputRetryable.make({ reason: "storage" }),
+              AgentInputError: () =>
+                ScheduleStorageError.make({ operation: "prepared admission", reason: "corrupt" }),
+              DigestError: () =>
+                ScheduleStorageError.make({ operation: "prepared admission", reason: "corrupt" }),
+              ThreadNotMaterialized: () => ScheduledInputRetryable.make({ reason: "storage" }),
+              AppendConflict: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
+              FenceRejected: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
+              DurableRuntimeFailpointError: () =>
+                ScheduledInputRetryable.make({ reason: "ambiguous" }),
+            }),
+          ),
+    });
+  }),
+);
+
+const preparedFromSchedule = (envelope: ScheduledEnvelope): PreparedInput => ({
+  schemaVersion: 1,
+  threadId: envelope.threadId,
+  deliveryPrincipal: envelope.deliveryPrincipal,
+  agentId: envelope.agentId,
+  definitions: envelope.definitions,
+  input: envelope.input,
+  inputDigest: envelope.inputDigest,
+  admissionKey: envelope.admissionKey,
+  authorization: envelope.authorization,
+});
+
+/** Compatibility adapter retaining Scheduling's public admission port. */
+export const cloudflareScheduledInputAdmissionLayer: Layer.Layer<
+  ScheduledInputAdmission,
+  never,
+  PreparedInputAdmission
+> = Layer.effect(
+  ScheduledInputAdmission,
+  Effect.map(PreparedInputAdmission, (admission) =>
+    ScheduledInputAdmission.of({
+      submit: (envelope) => admission.submit(preparedFromSchedule(envelope)),
+    }),
+  ),
+);