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

package/src/client.ts

@@ -1,4 +1,4 @@
-import { AgentId, AgentInputError, type ConversationId } from "@effect-agent/core";
+import { AgentId, AgentInputError, type ThreadId } from "@effect-agent/core";
 import {
   AbortCommand,
   AbortIntent,
@@ -9,8 +9,8 @@ import {
   ApprovalDecisionIntent,
   CanonicalRecordEnvelope,
   CanonicalSequence,
-  ConversationNotMaterialized,
-  ConversationStoreError,
+  ThreadNotMaterialized,
+  ThreadStoreError,
   DefinitionDigests,
   DigestError,
   DurableRuntimeFailpointError,
@@ -29,17 +29,18 @@ import {
   UnknownResolutionIntent,
   type DurableSubmitAgent,
   type DurableSubmitOptions,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
+import { BrowserCrypto } from "@effect/platform-browser";
 import { Context, Crypto, Duration, Effect, Layer, Schema } from "effect";
 import { RpcTracing } from "effect-cf";
 
 import { DurableAlarmError } from "./alarm.ts";
-import { ConversationObjectNamespace, type ConversationObjectRpc } from "./bindings.ts";
+import { ThreadObjectNamespace, type ThreadObjectRpc } from "./bindings.ts";
 import { cloudflareFailureSignals, safeCauseMessage } from "./boundary.ts";
 import { AdmissionLimitExceeded } from "./config.ts";
 
 /**
- * The Worker↔Conversation-Object host protocol (plan §1.4): Schema envelopes for the host
+ * The Worker↔Thread-Object host protocol (plan §1.4): Schema envelopes for the host
  * entry points (`submitEncoded`, `awaitSettlementEncoded`, `observePage`, `abortEncoded`,
  * `resolveApprovalEncoded`, `resolveUnknownEncoded`) plus the Worker-side client that speaks
  * it. Mirrors the WP2 port protocol: requests and responses are closed Schema unions, typed
@@ -70,10 +71,10 @@ export class HostProtocolError extends Schema.TaggedError<HostProtocolError>()(
 ) {}
 
 /** The Worker-side stub call itself failed (RPC rejection, overload, eviction mid-call). */
-export class ConversationClientError extends Schema.TaggedError<ConversationClientError>()(
-  "ConversationClientError",
+export class ThreadClientError extends Schema.TaggedError<ThreadClientError>()(
+  "ThreadClientError",
   {
-    conversationId: Schema.String,
+    threadId: Schema.String,
     message: Schema.String,
     cause: Schema.optionalKey(Schema.Defect()),
     /** Cloudflare's own classification for a failure safe to retry with a fresh stub. */
@@ -91,7 +92,7 @@ export class ConversationClientError extends Schema.TaggedError<ConversationClie
  * One durable submission, input ALREADY encoded by the caller through the Agent Binding's
  * input schema (the Worker bundles the same Agent definitions as the Object, so schema
  * validation happens client-side; the resolved Binding re-validates at claim time). The
- * Conversation identity is deliberately absent — the addressed Object IS the lane.
+ * Thread identity is deliberately absent — the addressed Object IS the lane.
  */
 export class SubmitRequest extends Schema.Class<SubmitRequest>(
   "@effect-agent/platform-cloudflare/SubmitRequest",
@@ -145,8 +146,8 @@ export const HostFailure = Schema.Union([
   UnknownResolutionConflict,
   JoinedToHost,
   LedgerError,
-  ConversationStoreError,
-  ConversationNotMaterialized,
+  ThreadStoreError,
+  ThreadNotMaterialized,
   AppendConflict,
   FenceRejected,
   DurableRuntimeFailpointError,
@@ -250,14 +251,14 @@ export const decodeHostResponse = Schema.decodeUnknownEffect(HostResponse);
 // Worker-side client
 // ---------------------------------------------------------------------------
 
-/** Failure surface of `CloudflareConversationClient.submit`. */
+/** Failure surface of `CloudflareThreadClient.submit`. */
 const ClientSubmitHostFailure = Schema.Union([
   AgentInputError,
   DigestError,
   AdmissionConflict,
   LedgerError,
-  ConversationStoreError,
-  ConversationNotMaterialized,
+  ThreadStoreError,
+  ThreadNotMaterialized,
   AppendConflict,
   FenceRejected,
   DurableRuntimeFailpointError,
@@ -265,14 +266,20 @@ const ClientSubmitHostFailure = Schema.Union([
   DurableAlarmError,
   HostProtocolError,
 ]);
-const ClientAwaitHostFailure = Schema.Union([LedgerError, SettlementConflict, HostProtocolError]);
+const ClientAwaitHostFailure = Schema.Union([
+  LedgerError,
+  SettlementConflict,
+  OperationDenied,
+  HostProtocolError,
+]);
 const ClientObserveHostFailure = Schema.Union([
-  ConversationStoreError,
-  ConversationNotMaterialized,
+  ThreadStoreError,
+  ThreadNotMaterialized,
   OperationDenied,
   HostProtocolError,
 ]);
 const ClientAbortHostFailure = Schema.Union([
+  OperationDenied,
   LedgerError,
   SettlementConflict,
   JoinedToHost,
@@ -299,23 +306,19 @@ const ClientUnknownHostFailure = Schema.Union([
   HostProtocolError,
 ]);
 
-export type ClientSubmitFailure = typeof ClientSubmitHostFailure.Type | ConversationClientError;
-export type ClientAwaitFailure = typeof ClientAwaitHostFailure.Type | ConversationClientError;
-export type ClientObserveFailure = typeof ClientObserveHostFailure.Type | ConversationClientError;
+export type ClientSubmitFailure = typeof ClientSubmitHostFailure.Type | ThreadClientError;
+export type ClientAwaitFailure = typeof ClientAwaitHostFailure.Type | ThreadClientError;
+export type ClientObserveFailure = typeof ClientObserveHostFailure.Type | ThreadClientError;
 export type ClientProgressFailure = ClientObserveFailure;
-export type ClientAbortFailure = typeof ClientAbortHostFailure.Type | ConversationClientError;
-export type ClientApprovalFailure = typeof ClientApprovalHostFailure.Type | ConversationClientError;
-export type ClientUnknownFailure = typeof ClientUnknownHostFailure.Type | ConversationClientError;
-
-const outOfContract = (
-  conversationId: string,
-  operation: string,
-  observed: string,
-): ConversationClientError =>
-  ConversationClientError.make({
-    conversationId,
+export type ClientAbortFailure = typeof ClientAbortHostFailure.Type | ThreadClientError;
+export type ClientApprovalFailure = typeof ClientApprovalHostFailure.Type | ThreadClientError;
+export type ClientUnknownFailure = typeof ClientUnknownHostFailure.Type | ThreadClientError;
+
+const outOfContract = (threadId: string, operation: string, observed: string): ThreadClientError =>
+  ThreadClientError.make({
+    threadId,
     message: boundHostDiagnostic(
-      `The Conversation Object answered ${operation} with the out-of-contract ${observed}.`,
+      `The Thread Object answered ${operation} with the out-of-contract ${observed}.`,
     ),
   });
 
@@ -328,11 +331,11 @@ const hostRpcMethods = {
   abort: "abortEncoded",
   resolveApproval: "resolveApprovalEncoded",
   resolveUnknown: "resolveUnknownEncoded",
-} as const satisfies Record<string, keyof ConversationObjectRpc>;
+} as const satisfies Record<string, keyof ThreadObjectRpc>;
 
-/** Worker-side client over the Conversation Object namespace (DEPLOY-010). */
-export class CloudflareConversationClient extends Context.Service<
-  CloudflareConversationClient,
+/** Worker-side client over the Thread Object namespace (DEPLOY-010). */
+export class CloudflareThreadClient extends Context.Service<
+  CloudflareThreadClient,
   {
     /** Encode the input client-side, then durably submit to the owning Object. */
     readonly submit: <InputSchema extends Schema.Top>(
@@ -347,12 +350,12 @@ export class CloudflareConversationClient extends Context.Service<
      * The result is deliberately void: canonical records remain authoritative and must be read.
      */
     readonly awaitProgress: (
-      conversationId: ConversationId,
+      threadId: ThreadId,
       afterSequence: CanonicalSequence,
     ) => Effect.Effect<void, ClientProgressFailure>;
     /** One bounded page of canonical records. */
     readonly readPage: (
-      conversationId: ConversationId,
+      threadId: ThreadId,
       options?: {
         readonly afterSequence?: CanonicalSequence | undefined;
         readonly limit?: number | undefined;
@@ -364,55 +367,69 @@ export class CloudflareConversationClient extends Context.Service<
      * `awaitSettlement`.
      */
     readonly readAll: (
-      conversationId: ConversationId,
+      threadId: ThreadId,
     ) => Effect.Effect<ReadonlyArray<CanonicalRecordEnvelope>, ClientObserveFailure>;
     /**
-     * Submission-addressed operations take the owning Conversation explicitly (from the
+     * Submission-addressed operations take the owning Thread explicitly (from the
      * Receipt): minted Submission identities stay OPAQUE outside the storage adapter that
      * minted them (D-P6-5), so the client never parses one to find the lane.
      */
     readonly abort: (
-      conversationId: ConversationId,
+      threadId: ThreadId,
       command: AbortCommand,
     ) => Effect.Effect<AbortIntent, ClientAbortFailure>;
     readonly resolveApproval: (
-      conversationId: ConversationId,
+      threadId: ThreadId,
       command: ApprovalDecisionCommand,
     ) => Effect.Effect<ApprovalDecisionIntent, ClientApprovalFailure>;
     readonly resolveUnknown: (
-      conversationId: ConversationId,
+      threadId: ThreadId,
       command: UnknownResolutionCommand,
     ) => Effect.Effect<UnknownResolutionIntent, ClientUnknownFailure>;
   }
->()("@effect-agent/platform-cloudflare/CloudflareConversationClient") {
+>()("@effect-agent/platform-cloudflare/CloudflareThreadClient") {
+  /**
+   * Assemble the client from a resolved namespace and the platform Crypto implementation.
+   * rpcTracing is the binding name and remains opt-in. Caller authentication, principals,
+   * idempotency keys, and definition digests are still explicit submission inputs.
+   */
+  static layerFromBinding(options: {
+    readonly namespace: DurableObjectNamespace<ThreadObjectRpc>;
+    readonly rpcTracing?: string;
+  }): Layer.Layer<CloudflareThreadClient> {
+    return CloudflareThreadClient.layer.pipe(
+      Layer.provide([ThreadObjectNamespace.layer(options.namespace, options), BrowserCrypto.layer]),
+    );
+  }
+
   static readonly layer: Layer.Layer<
-    CloudflareConversationClient,
+    CloudflareThreadClient,
     never,
-    ConversationObjectNamespace | Crypto.Crypto
-  > = Layer.effect(CloudflareConversationClient)(
+    ThreadObjectNamespace | Crypto.Crypto
+  > = Layer.effect(CloudflareThreadClient)(
     Effect.gen(function* () {
-      const { namespace, rpcTracing } = yield* ConversationObjectNamespace;
+      const { namespace, rpcTracing } = yield* ThreadObjectNamespace;
       const crypto = yield* Crypto.Crypto;
 
       const call = Effect.fn(
         function* (
-          conversationId: string,
+          threadId: string,
           operation: keyof typeof hostRpcMethods,
           encoded: unknown,
-        ): Effect.fn.Return<HostResponse, ConversationClientError | HostProtocolError> {
+        ): Effect.fn.Return<HostResponse, ThreadClientError | HostProtocolError> {
           // Empty arguments preserve native arity. Passing `undefined` still adds an argument.
           const traceArgs =
             rpcTracing === undefined ? [] : yield* RpcTracing.withRpcTraceContext([]);
           const raw = yield* Effect.tryPromise({
             try: () => {
-              const stub = namespace.get(namespace.idFromName(conversationId));
+              const stub = namespace.get(namespace.idFromName(threadId));
               return stub[hostRpcMethods[operation]](encoded, ...traceArgs);
             },
             catch: (cause) =>
-              ConversationClientError.make({
-                conversationId,
+              ThreadClientError.make({
+                threadId,
                 message: boundHostDiagnostic(
-                  `${operation} did not reach the Conversation Object: ${safeCauseMessage(
+                  `${operation} did not reach the Thread Object: ${safeCauseMessage(
                     cause,
                     "the RPC failed without a diagnostic",
                   )}`,
@@ -422,26 +439,25 @@ export class CloudflareConversationClient extends Context.Service<
               }),
           });
           return yield* decodeHostResponse(raw).pipe(
-            Effect.mapError(
-              (error): HostProtocolError =>
-                HostProtocolError.make({
-                  message: boundHostDiagnostic(
-                    `The ${operation} answer could not be decoded: ${error.message}`,
-                  ),
-                }),
+            Effect.mapError((error): HostProtocolError =>
+              HostProtocolError.make({
+                message: boundHostDiagnostic(
+                  `The ${operation} answer could not be decoded: ${error.message}`,
+                ),
+              }),
             ),
           );
         },
-        (effect, conversationId, operation) =>
+        (effect, threadId, operation) =>
           rpcTracing === undefined
-            ? Effect.withSpan(effect, "CloudflareConversationClient.call", {
-                attributes: { conversationId, operation },
+            ? Effect.withSpan(effect, "CloudflareThreadClient.call", {
+                attributes: { threadId, operation },
               })
             : RpcTracing.withRpcClientSpan(effect, rpcTracing, hostRpcMethods[operation]),
       );
 
       const expect = <ResultSchema extends Schema.Top, FailureSchema extends Schema.Top>(
-        conversationId: string,
+        threadId: string,
         operation: string,
         resultSchema: ResultSchema,
         failureSchema: FailureSchema,
@@ -450,22 +466,22 @@ export class CloudflareConversationClient extends Context.Service<
         const isExpectedFailure = Schema.is(failureSchema);
         return (
           response: HostResponse,
-        ): Effect.Effect<ResultSchema["Type"], FailureSchema["Type"] | ConversationClientError> => {
+        ): Effect.Effect<ResultSchema["Type"], FailureSchema["Type"] | ThreadClientError> => {
           if (response._tag === "HostFailed") {
             const failure = response.failure;
             return isExpectedFailure(failure)
               ? Effect.fail(failure)
-              : Effect.fail(outOfContract(conversationId, operation, `failure ${failure._tag}`));
+              : Effect.fail(outOfContract(threadId, operation, `failure ${failure._tag}`));
           }
           if (!isExpectedResult(response)) {
-            return Effect.fail(outOfContract(conversationId, operation, `result ${response._tag}`));
+            return Effect.fail(outOfContract(threadId, operation, `result ${response._tag}`));
           }
           return Effect.succeed(response);
         };
       };
 
       const readPage = (
-        conversationId: ConversationId,
+        threadId: ThreadId,
         options?: {
           readonly afterSequence?: CanonicalSequence | undefined;
           readonly limit?: number | undefined;
@@ -485,9 +501,9 @@ export class CloudflareConversationClient extends Context.Service<
               }),
             ),
           );
-          const response = yield* call(conversationId, "observePage", encoded);
+          const response = yield* call(threadId, "observePage", encoded);
           const page = yield* expect(
-            conversationId,
+            threadId,
             "observePage",
             ObservedPage,
             ClientObserveHostFailure,
@@ -495,18 +511,15 @@ export class CloudflareConversationClient extends Context.Service<
           return page.records;
         });
 
-      const cancelProgress = (
-        conversationId: ConversationId,
-        waiterId: string,
-      ): Effect.Effect<void> =>
+      const cancelProgress = (threadId: ThreadId, waiterId: string): Effect.Effect<void> =>
         encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(
           Effect.mapError(() => undefined),
-          Effect.flatMap((encoded) => call(conversationId, "cancelProgress", encoded)),
+          Effect.flatMap((encoded) => call(threadId, "cancelProgress", encoded)),
           Effect.asVoid,
           Effect.ignore,
         );
 
-      return CloudflareConversationClient.of({
+      return CloudflareThreadClient.of({
         submit: <InputSchema extends Schema.Top>(
           agent: DurableSubmitAgent<InputSchema>,
           input: InputSchema["Type"],
@@ -543,9 +556,9 @@ export class CloudflareConversationClient extends Context.Service<
                 }),
               ),
             );
-            const response = yield* call(options.conversationId, "submit", encoded);
+            const response = yield* call(options.threadId, "submit", encoded);
             const succeeded = yield* expect(
-              options.conversationId,
+              options.threadId,
               "submit",
               SubmitSucceeded,
               ClientSubmitHostFailure,
@@ -562,9 +575,9 @@ export class CloudflareConversationClient extends Context.Service<
                 }),
               ),
             );
-            const response = yield* call(receipt.conversationId, "awaitSettlement", encoded);
+            const response = yield* call(receipt.threadId, "awaitSettlement", encoded);
             const settled = yield* expect(
-              receipt.conversationId,
+              receipt.threadId,
               "awaitSettlement",
               SettlementReached,
               ClientAwaitHostFailure,
@@ -572,7 +585,7 @@ export class CloudflareConversationClient extends Context.Service<
             return settled.settlement;
           }),
 
-        awaitProgress: (conversationId, afterSequence) =>
+        awaitProgress: (threadId, afterSequence) =>
           Effect.gen(function* () {
             const waiterId = yield* crypto.randomUUIDv4.pipe(
               Effect.mapError((error) =>
@@ -595,17 +608,12 @@ export class CloudflareConversationClient extends Context.Service<
             );
 
             const attempt = (retry: number): Effect.Effect<void, ClientProgressFailure> =>
-              call(conversationId, "awaitProgress", encoded).pipe(
+              call(threadId, "awaitProgress", encoded).pipe(
                 Effect.flatMap(
-                  expect(
-                    conversationId,
-                    "awaitProgress",
-                    ProgressObserved,
-                    ClientObserveHostFailure,
-                  ),
+                  expect(threadId, "awaitProgress", ProgressObserved, ClientObserveHostFailure),
                 ),
                 Effect.asVoid,
-                Effect.catchTag("ConversationClientError", (error) =>
+                Effect.catchTag("ThreadClientError", (error) =>
                   error.retryable === true && error.overloaded !== true && retry < 5
                     ? Effect.sleep(Duration.millis(10 * 2 ** retry)).pipe(
                         Effect.andThen(attempt(retry + 1)),
@@ -614,19 +622,17 @@ export class CloudflareConversationClient extends Context.Service<
                 ),
               );
 
-            yield* attempt(0).pipe(
-              Effect.onInterrupt(() => cancelProgress(conversationId, waiterId)),
-            );
+            yield* attempt(0).pipe(Effect.onInterrupt(() => cancelProgress(threadId, waiterId)));
           }),
 
         readPage,
 
-        readAll: (conversationId) =>
+        readAll: (threadId) =>
           Effect.gen(function* () {
             const all: Array<CanonicalRecordEnvelope> = [];
             let after: CanonicalSequence | undefined;
             for (;;) {
-              const page = yield* readPage(conversationId, { afterSequence: after, limit: 1_024 });
+              const page = yield* readPage(threadId, { afterSequence: after, limit: 1_024 });
               all.push(...page);
               const last = page.at(-1);
               if (page.length < 1_024 || last === undefined) return all;
@@ -634,7 +640,7 @@ export class CloudflareConversationClient extends Context.Service<
             }
           }),
 
-        abort: (conversationId, command) =>
+        abort: (threadId, command) =>
           Effect.gen(function* () {
             const encoded = yield* encodeAbortCommand(command).pipe(
               Effect.mapError((error) =>
@@ -643,9 +649,9 @@ export class CloudflareConversationClient extends Context.Service<
                 }),
               ),
             );
-            const response = yield* call(conversationId, "abort", encoded);
+            const response = yield* call(threadId, "abort", encoded);
             const recorded = yield* expect(
-              conversationId,
+              threadId,
               "abort",
               AbortRecorded,
               ClientAbortHostFailure,
@@ -653,7 +659,7 @@ export class CloudflareConversationClient extends Context.Service<
             return recorded.intent;
           }),
 
-        resolveApproval: (conversationId, command) =>
+        resolveApproval: (threadId, command) =>
           Effect.gen(function* () {
             const encoded = yield* encodeApprovalDecisionCommand(command).pipe(
               Effect.mapError((error) =>
@@ -662,9 +668,9 @@ export class CloudflareConversationClient extends Context.Service<
                 }),
               ),
             );
-            const response = yield* call(conversationId, "resolveApproval", encoded);
+            const response = yield* call(threadId, "resolveApproval", encoded);
             const recorded = yield* expect(
-              conversationId,
+              threadId,
               "resolveApproval",
               ApprovalRecorded,
               ClientApprovalHostFailure,
@@ -672,7 +678,7 @@ export class CloudflareConversationClient extends Context.Service<
             return recorded.intent;
           }),
 
-        resolveUnknown: (conversationId, command) =>
+        resolveUnknown: (threadId, command) =>
           Effect.gen(function* () {
             const encoded = yield* encodeUnknownResolutionCommand(command).pipe(
               Effect.mapError((error) =>
@@ -683,9 +689,9 @@ export class CloudflareConversationClient extends Context.Service<
                 }),
               ),
             );
-            const response = yield* call(conversationId, "resolveUnknown", encoded);
+            const response = yield* call(threadId, "resolveUnknown", encoded);
             const recorded = yield* expect(
-              conversationId,
+              threadId,
               "resolveUnknown",
               UnknownResolutionRecorded,
               ClientUnknownHostFailure,

package/src/code-mode-executor.ts

@@ -814,3 +814,22 @@ export const dynamicWorkerCodeExecutorLayer = (
       return CodeExecutor.of({ execute: makeExecute(options, clock) });
     }),
   );
+
+/** Assemble Code Mode handlers with the isolated Dynamic Worker executor. */
+export const CloudflareCodeMode = {
+  /**
+   * Provide the selected tool handlers at construction, where Code Mode captures them.
+   * Their errors and remaining dependencies stay visible. The definition still owns the
+   * allowlist and limits; the runtime supplies the live Tool broker for each scoped pass.
+   */
+  layer: <A, E, R, Handlers, HandlerError, HandlerRequirements>(
+    definition: { readonly handlers: Layer.Layer<A, E, R> },
+    options: DynamicWorkerCodeExecutorOptions & {
+      readonly handlers: Layer.Layer<Handlers, HandlerError, HandlerRequirements>;
+    },
+  ) =>
+    definition.handlers.pipe(
+      Layer.provide(options.handlers),
+      Layer.provide(dynamicWorkerCodeExecutorLayer(options)),
+    ),
+};

package/src/config.ts

@@ -1,5 +1,5 @@
-import { DEFAULT_OWNERSHIP_LEASE_DURATION, DeploymentId } from "@effect-agent/session";
 import { DEFAULT_MAX_STORED_VALUE_BYTES } from "@effect-agent/storage-cloudflare";
+import { DEFAULT_OWNERSHIP_LEASE_DURATION, DeploymentId } from "@effect-agent/thread";
 import { Context, Duration, Schema } from "effect";
 
 /**
@@ -25,7 +25,7 @@ export class CloudflarePlatformConfigError extends Schema.TaggedError<Cloudflare
  * (deployment spec §8, DEPLOY-007: "Admission has explicit bounded quota and overload
  * behavior... a typed rejection"). This is the DC analogue of `NodeDurableHost`'s
  * `AdmissionClosed` host gate: the port surface stays untouched, the refusal happens in the
- * Conversation Object's submit entry point before `DurableAgentRuntime.submit` runs, and
+ * Thread Object's submit entry point before `DurableAgentRuntime.submit` runs, and
  * nothing was admitted or written.
  */
 export class AdmissionLimitExceeded extends Schema.TaggedError<AdmissionLimitExceeded>()(
@@ -52,13 +52,13 @@ export const CLOUDFLARE_DATABASE_CAP_BYTES = 10_000_000_000;
 export const DEFAULT_MAX_DATABASE_BYTES = 9_000_000_000;
 
 /**
- * Explicit bounded admission quotas checked by the Conversation Object BEFORE admission
+ * Explicit bounded admission quotas checked by the Thread Object BEFORE admission
  * (exit gate "resource limits are checked before admission").
  */
 export class CloudflareAdmissionLimitsValue extends Schema.Class<CloudflareAdmissionLimitsValue>(
   "@effect-agent/platform-cloudflare/CloudflareAdmissionLimitsValue",
 )({
-  /** Maximum nonterminal Submissions per Conversation lane before new admissions refuse. */
+  /** Maximum nonterminal Submissions per Thread lane before new admissions refuse. */
   maxQueueDepthPerLane: Schema.Int.check(
     Schema.isGreaterThan(0),
     Schema.isLessThanOrEqualTo(100_000),
@@ -74,7 +74,7 @@ export class CloudflareAdmissionLimitsValue extends Schema.Class<CloudflareAdmis
 
 /**
  * Validated Cloudflare durable runtime configuration. The producer identity of one
- * Conversation Object is `{producerPrefix}:{conversationId}` — stable across incarnations of
+ * Thread Object is `{producerPrefix}:{threadId}` — stable across incarnations of
  * the same deployment, distinct across deployments — and producer-epoch fencing (not the
  * producer name) remains the correctness authority (DUR-006).
  */
@@ -82,7 +82,7 @@ export class CloudflareDurableRuntimeConfigValue extends Schema.Class<Cloudflare
   "@effect-agent/platform-cloudflare/CloudflareDurableRuntimeConfigValue",
 )({
   deploymentId: DeploymentId,
-  /** Head of the minted producer identity `{producerPrefix}:{conversationId}`. */
+  /** Head of the minted producer identity `{producerPrefix}:{threadId}`. */
   producerPrefix: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
   /** Submission ownership lease duration (D5); fences work across Object incarnations. */
   ownershipLeaseDuration: PositiveMillis,
@@ -119,7 +119,7 @@ export class CloudflareDurableRuntimeConfig extends Context.Service<
   CloudflareDurableRuntimeConfigValue
 >()("@effect-agent/platform-cloudflare/CloudflareDurableRuntimeConfig") {}
 
-/** Documented production defaults applied by `CloudflareDurableRuntime.layer`. */
+/** Documented production defaults applied by `ThreadObject.layer`. */
 export const CLOUDFLARE_RUNTIME_DEFAULTS = {
   ownershipLeaseDuration: Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION),
   alarmBackoffBase: 100,

package/src/index.ts

@@ -2,14 +2,14 @@
  * `@effect-agent/platform-cloudflare` — the Cloudflare Layer-assembly library for deployment
  * class DC (deployment spec §12: a Layer-assembly library, not an application entrypoint).
  *
- * One SQLite-backed Durable Object per Conversation is the serialized owner (durability §6):
- * `makeConversationObjectClass` builds the class applications export from their Worker,
- * `CloudflareDurableRuntime.layer` assembles the coordinator over the storage-cloudflare
- * adapters and the WP2 cross-Object routing, `DurableAlarmService`/`ConversationMaintenance`
+ * One SQLite-backed Durable Object per Thread is the serialized owner (durability §6):
+ * `ThreadObject.make` builds the class applications export from their Worker,
+ * `ThreadObject.layer` assembles the coordinator over the storage-cloudflare
+ * adapters and the WP2 cross-Object routing, `DurableAlarmService`/`ThreadMaintenance`
  * multiplex every cadence into the Object's single alarm slot (dirty or autonomously
  * actionable work retains a committed alarm; stable external waits quiesce until their next
  * durably pre-armed mutation), and
- * `CloudflareConversationClient` is the Worker-side ingress. Platform bindings enter ONLY
+ * `CloudflareThreadClient` is the Worker-side ingress. Platform bindings enter ONLY
  * through the `bindings.ts` Layers (DEPLOY-010). This is the only workspace package allowed
  * to import the `cloudflare:workers` runtime module.
  */
@@ -19,12 +19,11 @@ 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";
+export { ThreadObjectPorts } from "./layers.ts";
+export * as ThreadObject from "./thread-object.ts";
 export * from "./client.ts";
+export * from "./prepared-admission.ts";
 export * from "./scheduling.ts";
+export * from "./subscriptions.ts";
 export * from "./code-mode-executor.ts";
-export * from "./browser-quick-action.ts";
-export * from "./browser-rest-capture.ts";
-export * from "./interactive-browser.ts";
-export * from "./browser-rest-crawl.ts";
+export { CloudflareBrowser, type CloudflareBrowserOptions } from "./browser-quick-action.ts";

package/src/interactive-browser.ts

@@ -44,7 +44,10 @@ import {
   type Scope,
 } from "effect";
 
-import { BrowserRunSessionLifecycle } from "./browser-session-lifecycle.ts";
+import {
+  BrowserRunSessionLifecycle,
+  type BrowserRunLifecycleOptions,
+} from "./browser-session-lifecycle.ts";
 export { BrowserRunCleanupError, BrowserRunSessionLifecycle } from "./browser-session-lifecycle.ts";
 
 export const browserRunInteractiveImplementation = SandboxImplementation.make({
@@ -2145,3 +2148,28 @@ export const browserRunInteractiveLayer = (): Layer.Layer<
       });
     }),
   );
+
+/** Resolved Worker binding, cleanup credentials, and optional initial viewport. */
+export interface CloudflareInteractiveBrowserOptions extends BrowserRunLifecycleOptions {
+  readonly browser: BrowserRun;
+  readonly viewport?: BrowserRunViewport;
+}
+
+const interactiveBindingLayer = (options: CloudflareInteractiveBrowserOptions) =>
+  BrowserRunInteractiveBinding.layer(options).pipe(
+    Layer.provide(BrowserRunSessionLifecycle.layer(options)),
+  );
+
+/** Worker-only assembly; importing ordinary capture never loads Puppeteer. */
+export const CloudflareInteractiveBrowser = {
+  /**
+   * Assemble binding, confirmed-session cleanup, and the generic browser service.
+   * HttpClient and construction errors remain visible. Opening a pass still requires
+   * an explicit policy and Scope; no browser is launched during Layer construction.
+   */
+  layer: (options: CloudflareInteractiveBrowserOptions) =>
+    browserRunInteractiveLayer().pipe(Layer.provide(interactiveBindingLayer(options))),
+  /** Opt into private host controls instead of exposing them through the generic service. */
+  hostLayer: (options: CloudflareInteractiveBrowserOptions) =>
+    browserRunInteractiveHostLayer().pipe(Layer.provide(interactiveBindingLayer(options))),
+};