@effect-agent/platform-cloudflare 0.1.0-beta.38 → 0.1.0-beta.40

package/src/{conversation-object.ts → thread-object.ts}

@@ -1,11 +1,16 @@
 import type { AgentId } from "@effect-agent/core";
 import { SubmissionId } from "@effect-agent/core";
+import {
+  decodePortRequest,
+  encodePortResponse,
+  type PortRequest,
+} from "@effect-agent/storage-cloudflare";
 import {
   AppendConflict,
-  ConversationNotMaterialized,
-  ConversationRead,
-  ConversationStore,
-  ConversationStoreError,
+  ThreadNotMaterialized,
+  ThreadRead,
+  ThreadStore,
+  ThreadStoreError,
   DigestError,
   DurableAgentRuntime,
   DurableRuntimeFailpointError,
@@ -29,12 +34,7 @@ import {
   SubmissionLookupByKey,
   WakeScheduler,
   type DurableSubmitAgent,
-} from "@effect-agent/session";
-import {
-  decodePortRequest,
-  encodePortResponse,
-  type PortRequest,
-} from "@effect-agent/storage-cloudflare";
+} from "@effect-agent/thread";
 import { Effect, Layer, Option, Schema, Stream } from "effect";
 import {
   DurableObject as EffectCfDurableObject,
@@ -43,16 +43,16 @@ import {
 } from "effect-cf";
 
 import {
-  ConversationMaintenance,
+  ThreadMaintenance,
   DurableAlarmError,
   DurableAlarmService,
   type MaintenancePassFailure,
 } from "./alarm.ts";
 import {
-  ConversationObjectIdentity,
+  ThreadObjectIdentity,
   DurableObjectContext,
-  ConversationObjectNamespace,
-  conversationNamespaceFromEnv,
+  ThreadObjectNamespace,
+  threadNamespaceFromEnv,
   type CloudflareBindingError,
 } from "./bindings.ts";
 import {
@@ -81,21 +81,31 @@ import {
 } from "./client.ts";
 import { AdmissionLimitExceeded, CloudflareDurableRuntimeConfig } from "./config.ts";
 import {
-  CloudflareDurableRuntime,
-  ConversationObjectPorts,
+  layerConfig,
+  ThreadObjectPorts,
   type CloudflareDurableRuntimeInitializationError,
   type CloudflareDurableRuntimeOptions,
   type CloudflareDurableRuntimeServices,
+  type CloudflareBootstrapServices,
 } from "./layers.ts";
 import { ProgressWaitRegistry } from "./progress-wait.ts";
 
+export {
+  layer,
+  layerConfig,
+  type CloudflareDurableRuntimeOptions as RuntimeOptions,
+  type CloudflareDurableRuntimeServices as Services,
+  type CloudflareDurableRuntimeInitializationError as InitializationError,
+  type CloudflareBootstrapServices as BootstrapServices,
+} from "./layers.ts";
+
 /**
- * `makeConversationObjectClass(options, observability?)` — the Conversation Durable Object
+ * `ThreadObject.make(application, options)` — the Thread 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
+ * One SQLite-backed Object per Thread is the serialized owner (durability §6); the
  * Object never runs `runResolvedWorker`'s infinite loop — each ingress event or alarm runs
- * ONE bounded `runRecovery` + `processConversationResolved` pass, and the persisted alarm
+ * ONE bounded `runRecovery` + `processThreadResolved` pass, and the persisted alarm
  * (the single multiplexed slot, D-P6-2) finishes accepted work across evictions WITHOUT any
  * incoming request.
  *
@@ -107,21 +117,37 @@ import { ProgressWaitRegistry } from "./progress-wait.ts";
  * `runRecovery` BEFORE any claim, so reconciliation still strictly precedes new work.
  */
 
-/** Construction options for one deployed Conversation Object class. */
-export interface ConversationObjectOptions extends CloudflareDurableRuntimeOptions {
+/** Construction options for one deployed Thread Object class. */
+export interface Options<
+  ApplicationServices = never,
+  EventServices = never,
+  EventLayerError = never,
+> extends CloudflareDurableRuntimeOptions {
   /** Accept transient native RPC tracing through effect-cf; disabled by default. */
   readonly rpcTracing?: boolean;
   /**
    * Name of the Worker `env` binding carrying THIS class's `DurableObjectNamespace` — the
-   * Object's route back to sibling Conversation Objects for the WP2 cross-Object port calls
+   * Object's route back to sibling Thread Objects for the WP2 cross-Object port calls
    * and remote wakes (DEPLOY-010: the binding enters through a Layer, never ambiently).
    */
   readonly namespaceBinding: string;
+  /** Acquired and finalized per native event, with access to the complete application runtime. */
+  readonly eventLayer?: Layer.Layer<
+    EventServices,
+    EventLayerError,
+    | RuntimeServices
+    | ApplicationServices
+    | EffectCfDurableObjectState.DurableObjectState
+    | WorkerEnvironment
+  >;
 }
 
-type EndpointServices = CloudflareDurableRuntimeServices | DurableObjectContext;
-type RuntimeServices = EndpointServices | ConversationObjectNamespace;
-type ConversationObjectInitializationError =
+type EndpointServices =
+  | CloudflareDurableRuntimeServices
+  | CloudflareBootstrapServices
+  | DurableObjectContext;
+type RuntimeServices = EndpointServices | ThreadObjectNamespace;
+type ThreadObjectInitializationError =
   | CloudflareDurableRuntimeInitializationError
   | CloudflareBindingError
   | MaintenancePassFailure;
@@ -190,55 +216,53 @@ const utf8Bytes = (value: PersistedJson): number =>
  * exempt: its accepted-work obligation already exists, and returning the original Receipt
  * consumes no new quota. Refusals are typed `AdmissionLimitExceeded` and nothing is written.
  */
-const gateAdmissionLimits = Effect.fn("ConversationObject.gateAdmissionLimits")(
-  function* (request: {
-    readonly principal: SubmissionLookupByKey["principal"];
-    readonly idempotencyKey: SubmissionLookupByKey["idempotencyKey"];
-    readonly inputPayload: PersistedJson;
-  }) {
-    const identity = yield* ConversationObjectIdentity;
-    const config = yield* CloudflareDurableRuntimeConfig;
-    const ledger = yield* SubmissionLedger;
-    const { ctx } = yield* DurableObjectContext;
-
-    const existing = yield* ledger.lookup(
-      SubmissionLookupByKey.make({
-        conversationId: identity.conversationId,
-        principal: request.principal,
-        idempotencyKey: request.idempotencyKey,
-      }),
-    );
-    if (Option.isSome(existing)) return;
-
-    const inputBytes = utf8Bytes(request.inputPayload);
-    if (inputBytes > config.limits.maxInputBytes) {
-      return yield* AdmissionLimitExceeded.make({
-        limit: "input-bytes",
-        actual: inputBytes,
-        maximum: config.limits.maxInputBytes,
-      });
-    }
+const gateAdmissionLimits = Effect.fn("ThreadObject.gateAdmissionLimits")(function* (request: {
+  readonly principal: SubmissionLookupByKey["principal"];
+  readonly idempotencyKey: SubmissionLookupByKey["idempotencyKey"];
+  readonly inputPayload: PersistedJson;
+}) {
+  const identity = yield* ThreadObjectIdentity;
+  const config = yield* CloudflareDurableRuntimeConfig;
+  const ledger = yield* SubmissionLedger;
+  const { ctx } = yield* DurableObjectContext;
+
+  const existing = yield* ledger.lookup(
+    SubmissionLookupByKey.make({
+      threadId: identity.threadId,
+      principal: request.principal,
+      idempotencyKey: request.idempotencyKey,
+    }),
+  );
+  if (Option.isSome(existing)) return;
+
+  const inputBytes = utf8Bytes(request.inputPayload);
+  if (inputBytes > config.limits.maxInputBytes) {
+    return yield* AdmissionLimitExceeded.make({
+      limit: "input-bytes",
+      actual: inputBytes,
+      maximum: config.limits.maxInputBytes,
+    });
+  }
 
-    // One Conversation per Object (durability §5): the local scan IS this lane's queue.
-    const nonterminal = yield* Stream.runCollect(ledger.scanNonterminal);
-    if (nonterminal.length >= config.limits.maxQueueDepthPerLane) {
-      return yield* AdmissionLimitExceeded.make({
-        limit: "queue-depth",
-        actual: nonterminal.length,
-        maximum: config.limits.maxQueueDepthPerLane,
-      });
-    }
+  // One Thread per Object (durability §5): the local scan IS this lane's queue.
+  const nonterminal = yield* Stream.runCollect(ledger.scanNonterminal);
+  if (nonterminal.length >= config.limits.maxQueueDepthPerLane) {
+    return yield* AdmissionLimitExceeded.make({
+      limit: "queue-depth",
+      actual: nonterminal.length,
+      maximum: config.limits.maxQueueDepthPerLane,
+    });
+  }
 
-    const databaseBytes = yield* Effect.sync(() => ctx.storage.sql.databaseSize);
-    if (databaseBytes > config.limits.maxDatabaseBytes) {
-      return yield* AdmissionLimitExceeded.make({
-        limit: "database-bytes",
-        actual: databaseBytes,
-        maximum: config.limits.maxDatabaseBytes,
-      });
-    }
-  },
-);
+  const databaseBytes = yield* Effect.sync(() => ctx.storage.sql.databaseSize);
+  if (databaseBytes > config.limits.maxDatabaseBytes) {
+    return yield* AdmissionLimitExceeded.make({
+      limit: "database-bytes",
+      actual: databaseBytes,
+      maximum: config.limits.maxDatabaseBytes,
+    });
+  }
+});
 
 /**
  * The submit-capable projection of an Agent Binding on the OBJECT side: the input arrived
@@ -258,15 +282,15 @@ const submitEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoin
     Effect.mapError(protocolFailure("The submit request could not be decoded")),
     Effect.flatMap((request) =>
       Effect.gen(function* () {
-        const identity = yield* ConversationObjectIdentity;
-        const maintenance = yield* ConversationMaintenance;
+        const identity = yield* ThreadObjectIdentity;
+        const maintenance = yield* ThreadMaintenance;
         const runtime = yield* DurableAgentRuntime;
         yield* gateAdmissionLimits(request);
         // Alarm invariant: the generation + alarm commit BEFORE the admission, and maintenance
         // cannot acknowledge that generation until this mutation leaves its public RPC seam.
         const receipt = yield* maintenance.withMutation(
           runtime.submit(passthroughSubmitAgent(request.agentId), request.inputPayload, {
-            conversationId: identity.conversationId,
+            threadId: identity.threadId,
             principal: request.principal,
             idempotencyKey: request.idempotencyKey,
             definitions: request.definitions,
@@ -300,14 +324,14 @@ const awaitProgressEndpoint = (encoded: unknown): Effect.Effect<unknown, never,
     Effect.mapError(protocolFailure("The progress request could not be decoded")),
     Effect.flatMap((request) =>
       Effect.gen(function* () {
-        const identity = yield* ConversationObjectIdentity;
+        const identity = yield* ThreadObjectIdentity;
         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),
+              runtime.awaitProgress(identity.threadId, request.afterSequence),
               cancelled,
             );
           }),
@@ -340,21 +364,21 @@ const observePageEndpoint = (encoded: unknown): Effect.Effect<unknown, never, En
     Effect.mapError(protocolFailure("The observe request could not be decoded")),
     Effect.flatMap((request) =>
       Effect.gen(function* () {
-        const identity = yield* ConversationObjectIdentity;
-        const store = yield* ConversationStore;
+        const identity = yield* ThreadObjectIdentity;
+        const store = yield* ThreadStore;
         // 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,
+            threadId: identity.threadId,
           }),
         );
         const records = yield* Stream.runCollect(
           store.read(
-            ConversationRead.make({
-              conversationId: identity.conversationId,
+            ThreadRead.make({
+              threadId: identity.threadId,
               ...(request.afterSequence === undefined
                 ? {}
                 : { afterSequence: request.afterSequence }),
@@ -374,7 +398,7 @@ const abortEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoint
     Effect.mapError(protocolFailure("The abort command could not be decoded")),
     Effect.flatMap((command) =>
       Effect.gen(function* () {
-        const maintenance = yield* ConversationMaintenance;
+        const maintenance = yield* ThreadMaintenance;
         const runtime = yield* DurableAgentRuntime;
         const intent = yield* maintenance.withMutation(runtime.abort(command));
         return AbortRecorded.make({ intent });
@@ -391,7 +415,7 @@ const resolveApprovalEndpoint = (
     Effect.mapError(protocolFailure("The approval command could not be decoded")),
     Effect.flatMap((command) =>
       Effect.gen(function* () {
-        const maintenance = yield* ConversationMaintenance;
+        const maintenance = yield* ThreadMaintenance;
         const runtime = yield* DurableAgentRuntime;
         const intent = yield* maintenance.withMutation(runtime.resolveApproval(command));
         return ApprovalRecorded.make({ intent });
@@ -408,7 +432,7 @@ const resolveUnknownEndpoint = (
     Effect.mapError(protocolFailure("The resolution command could not be decoded")),
     Effect.flatMap((command) =>
       Effect.gen(function* () {
-        const maintenance = yield* ConversationMaintenance;
+        const maintenance = yield* ThreadMaintenance;
         const runtime = yield* DurableAgentRuntime;
         const intent = yield* maintenance.withMutation(runtime.resolveUnknown(command));
         return UnknownResolutionRecorded.make({ intent });
@@ -447,8 +471,8 @@ export const AdminFailure = Schema.Union([
   DigestError,
   OwnershipLost,
   SettlementConflict,
-  ConversationStoreError,
-  ConversationNotMaterialized,
+  ThreadStoreError,
+  ThreadNotMaterialized,
   AppendConflict,
   FenceRejected,
   DurableRuntimeFailpointError,
@@ -533,11 +557,11 @@ const explainEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoi
     Effect.mapError(protocolFailure("The explain request could not be decoded")),
     Effect.flatMap((request) =>
       Effect.gen(function* () {
-        const identity = yield* ConversationObjectIdentity;
+        const identity = yield* ThreadObjectIdentity;
         const runtime = yield* DurableAgentRuntime;
         const explanations =
           request.submissionId === undefined
-            ? yield* runtime.explainConversation(identity.conversationId)
+            ? yield* runtime.explainThread(identity.threadId)
             : [yield* runtime.explain(request.submissionId)];
         return ExplainedRecovery.make({ explanations });
       }),
@@ -551,9 +575,9 @@ const verifyEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoin
     Effect.mapError(protocolFailure("The verify request could not be decoded")),
     Effect.flatMap(() =>
       Effect.gen(function* () {
-        const identity = yield* ConversationObjectIdentity;
+        const identity = yield* ThreadObjectIdentity;
         const runtime = yield* DurableAgentRuntime;
-        const report = yield* runtime.verify(identity.conversationId);
+        const report = yield* runtime.verify(identity.threadId);
         return VerifiedIntegrity.make({ report });
       }),
     ),
@@ -566,7 +590,7 @@ const retryEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpoint
     Effect.mapError(protocolFailure("The retry command could not be decoded")),
     Effect.flatMap((command) =>
       Effect.gen(function* () {
-        const maintenance = yield* ConversationMaintenance;
+        const maintenance = yield* ThreadMaintenance;
         const runtime = yield* DurableAgentRuntime;
         // Retry may repair durable state, so its generation + alarm commit before the mutation.
         const report = yield* maintenance.withMutation(runtime.retry(command));
@@ -600,8 +624,8 @@ const obligationsEndpoint = (encoded: unknown): Effect.Effect<unknown, never, En
  */
 const portCallEndpoint = (encoded: unknown): Effect.Effect<unknown, never, EndpointServices> =>
   Effect.gen(function* () {
-    const ports = yield* ConversationObjectPorts;
-    const maintenance = yield* ConversationMaintenance;
+    const ports = yield* ThreadObjectPorts;
+    const maintenance = yield* ThreadMaintenance;
     const alarm = yield* DurableAlarmService;
     const decoded = yield* decodePortRequest(encoded).pipe(
       Effect.map((request) => ({ _tag: "success" as const, request })),
@@ -636,7 +660,7 @@ const portCallEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpo
       // Prompt processing hint; the pre-armed alarm already guarantees convergence.
       yield* alarm.scheduleNow.pipe(
         Effect.catch((error) =>
-          Effect.logWarning("ConversationObject.portCall: immediate re-arm failed", error),
+          Effect.logWarning("ThreadObject.portCall: immediate re-arm failed", error),
         ),
       );
     }
@@ -644,16 +668,16 @@ const portCallEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpo
   });
 
 const wakeEndpoint: Effect.Effect<void, never, EndpointServices> = Effect.gen(function* () {
-  const identity = yield* ConversationObjectIdentity;
+  const identity = yield* ThreadObjectIdentity;
   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);
+  yield* wake.notify(identity.threadId);
 });
 
 const alarmEndpoint: Effect.Effect<void, MaintenancePassFailure, EndpointServices> = Effect.gen(
   function* () {
-    const maintenance = yield* ConversationMaintenance;
+    const maintenance = yield* ThreadMaintenance;
     // Typed pass failures propagate: the rejected promise makes workerd retry the alarm
     // (at-least-once delivery), and the dirty generation retains a committed slot meanwhile.
     yield* maintenance.pass;
@@ -662,10 +686,10 @@ const alarmEndpoint: Effect.Effect<void, MaintenancePassFailure, EndpointService
 
 const gateEndpoint: Effect.Effect<void, MaintenancePassFailure, EndpointServices> = Effect.gen(
   function* () {
-    // Forcing ConversationMaintenance forces the whole Layer stack: migration + exact-version
+    // Forcing ThreadMaintenance 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;
+    const maintenance = yield* ThreadMaintenance;
     yield* maintenance.ensureAlarm;
   },
 );
@@ -679,7 +703,7 @@ const effectCfPlatformLayer = (
   namespaceBinding: string,
   rpcTracing = false,
 ): Layer.Layer<
-  DurableObjectContext | ConversationObjectNamespace,
+  DurableObjectContext | ThreadObjectNamespace,
   CloudflareBindingError,
   EffectCfDurableObjectState.DurableObjectState | WorkerEnvironment
 > => {
@@ -690,11 +714,11 @@ const effectCfPlatformLayer = (
       return DurableObjectContext.of({ ctx: state.raw, env });
     }),
   );
-  const namespace = Layer.effect(ConversationObjectNamespace)(
+  const namespace = Layer.effect(ThreadObjectNamespace)(
     Effect.gen(function* () {
       const env = yield* WorkerEnvironment;
-      const binding = yield* conversationNamespaceFromEnv(env, namespaceBinding);
-      return ConversationObjectNamespace.of({
+      const binding = yield* threadNamespaceFromEnv(env, namespaceBinding);
+      return ThreadObjectNamespace.of({
         namespace: binding,
         ...(rpcTracing === true ? { rpcTracing: namespaceBinding } : {}),
       });
@@ -703,8 +727,8 @@ const effectCfPlatformLayer = (
   return Layer.merge(context, namespace);
 };
 
-/** The public endpoints and effect-cf invocation hook of one Conversation Object instance. */
-export interface ConversationObjectInstance<EventServices = never> extends InstanceType<
+/** The public endpoints and effect-cf invocation hook of one Thread Object instance. */
+export interface Instance<EventServices = never> extends InstanceType<
   EffectCfDurableObject.DurableObjectClass<Record<never, never>, RuntimeServices | EventServices>
 > {
   submitEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
@@ -724,34 +748,39 @@ export interface ConversationObjectInstance<EventServices = never> extends Insta
   alarm(alarmInfo?: AlarmInvocationInfo): Promise<void> | void;
 }
 
-/** The constructor shape workerd instantiates for each Conversation Object. */
-export interface ConversationObjectClass<EventServices = never> {
-  new (ctx: DurableObjectState, env: Cloudflare.Env): ConversationObjectInstance<EventServices>;
+/** The constructor shape workerd instantiates for each Thread Object. */
+export interface Class<EventServices = never> {
+  new (ctx: DurableObjectState, env: Cloudflare.Env): Instance<EventServices>;
 }
 
 /**
- * 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 a composed application Layer as a native Durable Object class.
+ * Bootstrap services are provided to the whole graph before it acquires, so application Layers
+ * can yield effect-cf's WorkerEnvironment and DurableObjectState, derived identity, and Crypto.
+ * Application dependencies remain visible until Layer.provide satisfies them. effect-cf owns the
+ * cached ManagedRuntime, native RPC methods, event scopes, and telemetry flushing.
+ * Initialization is local and bounded inside the constructor gate. Cloudflare eviction does not
+ * guarantee finalizers; put resources requiring timely release in scoped operations or eventLayer.
  */
-export const makeConversationObjectClass = <EventLayerError = never, EventServices = never>(
-  options: ConversationObjectOptions,
-  observability?: Layer.Layer<
-    EventServices,
-    EventLayerError,
-    | DurableObjectContext
-    | ConversationObjectNamespace
+export const make = <
+  ApplicationServices,
+  ApplicationError,
+  EventServices = never,
+  EventLayerError = never,
+>(
+  applicationLayer: Layer.Layer<
+    CloudflareDurableRuntimeServices | ApplicationServices,
+    ApplicationError,
+    | CloudflareBootstrapServices
     | EffectCfDurableObjectState.DurableObjectState
     | WorkerEnvironment
+    | DurableObjectContext
+    | ThreadObjectNamespace
   >,
-): ConversationObjectClass<EventServices> => {
-  const application: Layer.Layer<
-    RuntimeServices,
-    CloudflareDurableRuntimeInitializationError | CloudflareBindingError,
-    EffectCfDurableObjectState.DurableObjectState | WorkerEnvironment
-  > = CloudflareDurableRuntime.layer(options).pipe(
+  options: Options<ApplicationServices, EventServices, EventLayerError>,
+): Class<ApplicationServices | EventServices> => {
+  const application = applicationLayer.pipe(
+    Layer.provideMerge(layerConfig(options)),
     Layer.provideMerge(effectCfPlatformLayer(options.namespaceBinding, options.rpcTracing)),
   );
 
@@ -759,8 +788,8 @@ export const makeConversationObjectClass = <EventLayerError = never, EventServic
   // 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,
+    RuntimeServices | ApplicationServices,
+    ThreadObjectInitializationError | ApplicationError,
     EffectCfDurableObjectState.DurableObjectState | WorkerEnvironment
   > = Layer.effectContext(
     Effect.gen(function* () {
@@ -791,17 +820,19 @@ export const makeConversationObjectClass = <EventLayerError = never, EventServic
     obligationsEncoded: (encoded: unknown) => obligationsEndpoint(encoded),
     portCall: (encoded: unknown) => portCallEndpoint(encoded),
     wake: () => wakeEndpoint,
-  } satisfies EffectCfDurableObject.DurableObjectRpc<RuntimeServices | EventServices>;
+  } satisfies EffectCfDurableObject.DurableObjectRpc<
+    RuntimeServices | ApplicationServices | EventServices
+  >;
 
-  const EffectCfConversationObject = EffectCfDurableObject.make<
-    RuntimeServices,
-    ConversationObjectInitializationError,
+  const EffectCfThreadObject = EffectCfDurableObject.make<
+    RuntimeServices | ApplicationServices,
+    ThreadObjectInitializationError | ApplicationError,
     EventServices,
     EventLayerError,
     typeof rpc
   >(runtime, {
     ...(options.rpcTracing === true ? { rpcTracing: { service: options.namespaceBinding } } : {}),
-    ...(observability === undefined ? {} : { eventLayer: observability }),
+    ...(options.eventLayer === undefined ? {} : { eventLayer: options.eventLayer }),
     // 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,
@@ -812,11 +843,11 @@ export const makeConversationObjectClass = <EventLayerError = never, EventServic
   // 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 {
+  class ThreadObject extends EffectCfThreadObject {
     override alarm(alarmInfo?: AlarmInvocationInfo): Promise<void> | void {
       return super.alarm?.(alarmInfo);
     }
   }
 
-  return ConversationObject;
+  return ThreadObject;
 };

package/src/transport.ts

@@ -1,12 +1,12 @@
-import { ConversationPortTransport, portTransportFailure } from "@effect-agent/storage-cloudflare";
+import { ThreadPortTransport, portTransportFailure } from "@effect-agent/storage-cloudflare";
 import { Effect, Layer } from "effect";
 
-import { ConversationObjectNamespace } from "./bindings.ts";
+import { ThreadObjectNamespace } from "./bindings.ts";
 
 /**
- * `ConversationPortTransport` over native Durable Object JS RPC (decision D-P6-3): one
- * `portCall(envelope)` on the stub of the Object that owns the addressed Conversation
- * (`namespace.idFromName(conversationId)` — the identity rule, plan §1.2). The envelopes are
+ * `ThreadPortTransport` over native Durable Object JS RPC (decision D-P6-3): one
+ * `portCall(envelope)` on the stub of the Object that owns the addressed Thread
+ * (`namespace.idFromName(threadId)` — the identity rule, plan §1.2). The envelopes are
  * already Schema-encoded JSON, so the RPC boundary carries only structured-cloneable values;
  * the protocol module stays transport-agnostic and fetch-with-JSON remains the documented
  * fallback carrier.
@@ -16,21 +16,21 @@ import { ConversationObjectNamespace } from "./bindings.ts";
  * when present) and NEVER as a fabricated answer: on `resolveAdmission` the routing layer
  * turns exactly this error into `AdmissionIndeterminate` (SUB-031).
  */
-export const conversationPortTransportLayer: Layer.Layer<
-  ConversationPortTransport,
+export const threadPortTransportLayer: Layer.Layer<
+  ThreadPortTransport,
   never,
-  ConversationObjectNamespace
-> = Layer.effect(ConversationPortTransport)(
+  ThreadObjectNamespace
+> = Layer.effect(ThreadPortTransport)(
   Effect.gen(function* () {
-    const { namespace } = yield* ConversationObjectNamespace;
-    return ConversationPortTransport.of({
-      call: (conversationId, request) =>
+    const { namespace } = yield* ThreadObjectNamespace;
+    return ThreadPortTransport.of({
+      call: (threadId, request) =>
         Effect.tryPromise({
-          try: () => namespace.get(namespace.idFromName(conversationId)).portCall(request),
-          catch: (cause) => portTransportFailure(conversationId, cause),
+          try: () => namespace.get(namespace.idFromName(threadId)).portCall(request),
+          catch: (cause) => portTransportFailure(threadId, cause),
         }).pipe(
           Effect.withSpan("CloudflarePortTransport.call", {
-            attributes: { conversationId },
+            attributes: { threadId },
           }),
         ),
     });