@yielded/agent-platform-cloudflare 0.1.0-beta.174 → 0.1.0-beta.176

package/src/CloudflareThreadClient.ts

@@ -386,13 +386,14 @@ const liveTextProtocolFailure = () =>
     message: "Provisional text is incomplete or invalid; discard drafts and read canonical records",
   });
 
+const decodeLiveTextFrame = Schema.decodeUnknownSync(Schema.fromJsonString(LiveTextFrame));
+
 const decodeLiveText = (
   threadId: ThreadId,
   source: ReadableStream<unknown>,
 ): Stream.Stream<LiveTextFrame, HostProtocolError | ThreadClientError> =>
   Stream.suspend(() => {
     const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
-    const decode = Schema.decodeUnknownSync(Schema.fromJsonString(LiveTextFrame));
     let pending = "";
     let pendingBytes = 0;
     let expected = 0;
@@ -488,7 +489,7 @@ const decodeLiveText = (
             if (newline < 0) break;
 
             const frame = yield* Effect.try({
-              try: () => decode(pending),
+              try: () => decodeLiveTextFrame(pending),
               catch: liveTextProtocolFailure,
             });
 

package/src/ThreadObject.ts

@@ -351,16 +351,17 @@ const gateAdmissionLimits = Effect.fnUntraced(function* (
     );
   }
 
-  const nonterminal = yield* ledger.scanNonterminal.pipe(
-    Stream.filter((submission) => submission.threadId === threadId),
-    Stream.runCollect,
+  const queueDepth = yield* Stream.runFold(
+    ledger.scanNonterminal,
+    () => 0,
+    (depth, submission) => depth + (submission.threadId === threadId ? 1 : 0),
   );
 
-  if (nonterminal.length >= config.limits.maxQueueDepthPerLane) {
+  if (queueDepth >= config.limits.maxQueueDepthPerLane) {
     return yield* refuseFresh(
       AdmissionLimitExceeded.make({
         limit: "queue-depth",
-        actual: nonterminal.length,
+        actual: queueDepth,
         maximum: config.limits.maxQueueDepthPerLane,
       }),
     );
@@ -1186,31 +1187,25 @@ const effectCfPlatformLayer = (
   DurableObjectContext | ThreadObjectNamespace,
   CloudflareBindingError,
   EffectCfDurableObjectState.DurableObjectState | WorkerEnvironment
-> => {
-  const context = Layer.effect(DurableObjectContext)(
+> =>
+  Layer.effectContext(
     Effect.gen(function* () {
       const state = yield* EffectCfDurableObjectState.DurableObjectState;
       const env = yield* WorkerEnvironment;
-
-      return DurableObjectContext.of({ ctx: state.raw, env });
-    }),
-  );
-
-  const namespace = Layer.effect(ThreadObjectNamespace)(
-    Effect.gen(function* () {
-      const env = yield* WorkerEnvironment;
       const binding = yield* threadNamespaceFromEnv(env, namespaceBinding);
 
-      return ThreadObjectNamespace.of({
-        get: (threadId) => binding.get(binding.idFromName(threadId)),
-        ...(rpcTracing === true ? { rpcTracing: namespaceBinding } : {}),
-      });
+      return Context.make(DurableObjectContext, { ctx: state.raw, env }).pipe(
+        Context.add(
+          ThreadObjectNamespace,
+          ThreadObjectNamespace.of({
+            get: (threadId) => binding.get(binding.idFromName(threadId)),
+            ...(rpcTracing === true ? { rpcTracing: namespaceBinding } : {}),
+          }),
+        ),
+      );
     }),
   );
 
-  return Layer.merge(context, namespace);
-};
-
 /** The public endpoints and effect-cf invocation hook of one Thread Object instance. */
 export interface Instance<EventServices = never> extends InstanceType<
   EffectCfDurableObject.DurableObjectClass<

package/src/internal/layers.ts

@@ -7,6 +7,7 @@ import {
 import { submissionLedgerLayer } from "@yielded/agent-storage-cloudflare/do-submission-ledger";
 import {
   threadStoreLayer,
+  journalLayer,
   storageConfigLayer,
   storageFailpointLayer,
   sqlOwnerLayer,
@@ -83,8 +84,15 @@ import {
   type WorkerStopCommand,
 } from "@yielded/agent/submission-ledger";
 import { ThreadProjectionMaintenance } from "@yielded/agent/thread-projection-maintenance";
-import type { ThreadReader } from "@yielded/agent/thread-store";
-import { AppendResult, ThreadStoreError, ThreadStore } from "@yielded/agent/thread-store";
+import {
+  type ThreadReader,
+  AppendResult,
+  type AppendRequest,
+  type ThreadStoreFailure,
+  PreparedAppend,
+  ThreadStoreError,
+  ThreadStore,
+} from "@yielded/agent/thread-store";
 import { ToolReconciler } from "@yielded/agent/tool-reconciler";
 import { type WakeScheduler } from "@yielded/agent/wake-scheduler";
 import {
@@ -134,7 +142,7 @@ import * as DueQueue from "./due-queue.ts";
 import { LiveTextHub } from "./live-text.ts";
 import {
   guardedMessageDeliveryStoreLayer,
-  threadMessageDeliveryLayer,
+  lazyThreadMessageDeliveryLayer,
 } from "./message-delivery.ts";
 import { cloudflarePreparedInputAdmissionLayer } from "./prepared-admission.ts";
 import { ProgressWaitRegistry } from "./progress-wait.ts";
@@ -625,10 +633,14 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
         verifyOnOpen: config.verifyOnOpen,
       };
 
-      const infrastructure = Layer.mergeAll(
-        options.lifecyclePublication === undefined ? Layer.empty : lifecyclePublicationLayer,
-        storageConfigLayer(storageOptions),
-        Layer.effect(SqlClient)(SqlClient),
+      // Memoize these shared compositions within this Object's build, so repeated
+      // consumers reuse their contexts as well as the scoped leaf services.
+      const infrastructure = Layer.suspend(() =>
+        Layer.mergeAll(
+          options.lifecyclePublication === undefined ? Layer.empty : lifecyclePublicationLayer,
+          storageConfigLayer(storageOptions),
+          Layer.effect(SqlClient)(SqlClient),
+        ),
       );
 
       // Preserve the database owner's reader gate and rollback invalidators, while
@@ -661,7 +673,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
         }),
       ).pipe(Layer.provide(sqlOwnerLayer));
 
-      const localInfrastructure = Layer.mergeAll(infrastructure, sourceOwner);
+      const localInfrastructure = Layer.suspend(() => Layer.mergeAll(infrastructure, sourceOwner));
 
       const sourceProgress = Layer.effect(SqlStorageProgress)(
         Effect.gen(function* () {
@@ -709,41 +721,58 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
 
       // 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 rawLocalPorts = Layer.mergeAll(threadStoreLayer, submissionLedgerLayer).pipe(
-        Layer.provide(localInfrastructure),
-        Layer.provide(sourceProgress),
+      const rawLocalPorts = Layer.suspend(() =>
+        Layer.mergeAll(threadStoreLayer, submissionLedgerLayer).pipe(
+          Layer.provide(journalLayer),
+          Layer.provide(localInfrastructure),
+          Layer.provide(sourceProgress),
+        ),
+      );
+
+      const base = Layer.suspend(() =>
+        Layer.mergeAll(DurableAlarmService.layer, ProgressWaitRegistry.layer),
       );
 
-      const base = Layer.mergeAll(DurableAlarmService.layer, ProgressWaitRegistry.layer);
       const wakes = cloudflareWakeSchedulerLayer.pipe(Layer.provide(base));
 
-      const messageStore = guardedMessageDeliveryStoreLayer.pipe(
-        Layer.provide(
-          doMessageDeliveryStoreLayer().pipe(
-            Layer.provide(localInfrastructure),
-            Layer.provide(sourceProgress),
+      const messageStore = Layer.suspend(() =>
+        guardedMessageDeliveryStoreLayer.pipe(
+          Layer.provide(
+            doMessageDeliveryStoreLayer().pipe(
+              Layer.provide(localInfrastructure),
+              Layer.provide(sourceProgress),
+            ),
           ),
+          Layer.provide(wakes),
         ),
-        Layer.provide(wakes),
       );
 
-      const messageRecovery = threadMessageDeliveryLayer.pipe(
-        // Four parallel attempts per wave. Native completion stops new wake-driven waves;
-        // retained retry deadlines schedule future alarms.
-        Layer.provide(MessageDeliveryDriver.layer({ batchSize: 4, concurrency: 4 })),
-        Layer.provide(cloudflarePreparedInputAdmissionLayer),
-        Layer.provide(CloudflareThreadClient.layer),
-        Layer.provide(messageStore),
-        Layer.provide(wakes),
+      const messageRecovery = Layer.suspend(() =>
+        lazyThreadMessageDeliveryLayer(
+          // Four parallel attempts per wave. Native completion stops new wake-driven waves;
+          // retained retry deadlines schedule future alarms.
+          MessageDeliveryDriver.layer({ batchSize: 4, concurrency: 4 }).pipe(
+            Layer.provide(cloudflarePreparedInputAdmissionLayer),
+            Layer.provide(CloudflareThreadClient.layer),
+            Layer.provide(messageStore),
+            Layer.provide(wakes),
+          ),
+        ).pipe(Layer.provide(messageStore)),
       );
 
-      const publication = (options.publication ?? ThreadPublication.layer).pipe(
-        Layer.provide(Layer.mergeAll(rawLocalPorts, Layer.effect(SqlClient)(SqlClient))),
-      );
+      const publication =
+        options.publication === undefined
+          ? ThreadPublication.layer
+          : options.publication.pipe(
+              Layer.provide(Layer.mergeAll(rawLocalPorts, Layer.effect(SqlClient)(SqlClient))),
+            );
 
-      const projection = (options.projection ?? ThreadProjectionMaintenance.layer).pipe(
-        Layer.provide(Layer.mergeAll(rawLocalPorts, Layer.effect(SqlClient)(SqlClient))),
-      );
+      const projection =
+        options.projection === undefined
+          ? ThreadProjectionMaintenance.layer
+          : options.projection.pipe(
+              Layer.provide(Layer.mergeAll(rawLocalPorts, Layer.effect(SqlClient)(SqlClient))),
+            );
 
       const localPorts =
         options.publication === undefined &&
@@ -765,6 +794,54 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                 // Publication remains outside this local source/index critical section.
                 const sourceCommits = yield* Semaphore.make(1);
 
+                const observeAppend = (
+                  request: AppendRequest,
+                  body: Effect.Effect<AppendResult, ThreadStoreFailure>,
+                ) =>
+                  mutations
+                    .withMutation(
+                      sourceCommits
+                        .withPermit(
+                          body.pipe(
+                            Effect.tap((result) =>
+                              index
+                                .applyCommitted(request, result)
+                                .pipe(
+                                  Effect.catchCause((cause) =>
+                                    Cause.hasInterrupts(cause)
+                                      ? Effect.interrupt
+                                      : Effect.logError(
+                                          "Thread projection deferred after source commit",
+                                          cause,
+                                        ),
+                                  ),
+                                ),
+                            ),
+                          ),
+                        )
+                        .pipe(Effect.tap(() => afterCommit)),
+                      {
+                        lanes: [
+                          ...(options.projection === undefined ? [] : [DueQueue.Projection]),
+                          ...(options.lifecyclePublication === undefined ||
+                          !request.batch.records.some((record) =>
+                            Schema.is(Schema.toType(LifecyclePublicationFact))(record.payload),
+                          )
+                            ? []
+                            : [DueQueue.Lifecycle]),
+                        ],
+                      },
+                    )
+                    .pipe(
+                      Effect.catchTag("DurableAlarmError", (cause) =>
+                        ThreadStoreError.make({
+                          operation: "prearm publication append",
+                          message: cause.message,
+                          cause,
+                        }),
+                      ),
+                    );
+
                 // Every runtime-owned producer prearms too: a crash between commit and invalidation
                 // leaves a NEW, uncertified generation. Source errors keep their native port types.
                 const observedStore = ThreadStore.of({
@@ -787,52 +864,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                               ),
                         },
                       }),
-                  append: (request) =>
-                    mutations
-                      .withMutation(
-                        sourceCommits
-                          .withPermit(
-                            store
-                              .append(request)
-                              .pipe(
-                                Effect.tap((result) =>
-                                  index
-                                    .applyCommitted(request, result)
-                                    .pipe(
-                                      Effect.catchCause((cause) =>
-                                        Cause.hasInterrupts(cause)
-                                          ? Effect.interrupt
-                                          : Effect.logError(
-                                              "Thread projection deferred after source commit",
-                                              cause,
-                                            ),
-                                      ),
-                                    ),
-                                ),
-                              ),
-                          )
-                          .pipe(Effect.tap(() => afterCommit)),
-                        {
-                          lanes: [
-                            ...(options.projection === undefined ? [] : [DueQueue.Projection]),
-                            ...(options.lifecyclePublication === undefined ||
-                            !request.batch.records.some((record) =>
-                              Schema.is(Schema.toType(LifecyclePublicationFact))(record.payload),
-                            )
-                              ? []
-                              : [DueQueue.Lifecycle]),
-                          ],
-                        },
-                      )
-                      .pipe(
-                        Effect.catchTag("DurableAlarmError", (cause) =>
-                          ThreadStoreError.make({
-                            operation: "prearm publication append",
-                            message: cause.message,
-                            cause,
-                          }),
-                        ),
-                      ),
+                  append: (request) => observeAppend(request, store.append(request)),
                 });
 
                 const observeIntent = <A, Failure>(
@@ -886,6 +918,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                   );
 
                 const stopWorker = ledger.stopWorker;
+                const appendInput = ledger.appendInput;
 
                 return Context.make(ThreadStore, observedStore).pipe(
                   Context.add(StorageOwner, storageOwner),
@@ -947,13 +980,22 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                   }),
                   Context.add(SubmissionLedger, {
                     ...ledger,
-                    ...(options.hostLanesForMutation === undefined
+                    ...(appendInput === undefined
+                      ? {}
+                      : {
+                          appendInput: (submissionId, input) =>
+                            Effect.flatMap(PreparedAppend.capture(input), (request) =>
+                              observeAppend(request, appendInput(submissionId, request)),
+                            ),
+                        }),
+                    ...(options.hostLanesForMutation === undefined &&
+                    options.lifecyclePublication === undefined
                       ? {}
                       : {
-                          admit: (request: AdmissionRequest) =>
+                          admit: (...args: Parameters<SubmissionLedger["Service"]["admit"]>) =>
                             observeMutation(
-                              { _tag: "Admission", request },
-                              ledger.admit(request),
+                              { _tag: "Admission", request: args[0] },
+                              ledger.admit(...args),
                               false,
                             ),
                         }),

package/src/internal/message-delivery.ts

@@ -5,7 +5,7 @@ import {
   MessageDeliveryStore,
 } from "@yielded/agent/message-delivery";
 import { WakeScheduler } from "@yielded/agent/wake-scheduler";
-import { Clock, Context, Effect, Layer, Option } from "effect";
+import { Clock, Context, Duration, Effect, Exit, Layer, Option } from "effect";
 
 import { DurableAlarmError, ThreadMessageDelivery, ThreadMutationGate } from "../Alarm.ts";
 import { ThreadObjectPlacement } from "../CloudflareBindings.ts";
@@ -76,45 +76,69 @@ export const guardedMessageDeliveryStoreLayer = Layer.effect(
   }),
 );
 
-/** Message progress shares the native alarm slot without blocking source runtime work. */
-export const threadMessageDeliveryLayer = Layer.effectContext(
-  Effect.gen(function* () {
-    const driver = yield* MessageDeliveryDriver;
-    const store = yield* MessageDeliveryStore;
+/** Build the driver in the Object's Scope only when retained delivery work is due. */
+export const lazyThreadMessageDeliveryLayer = <E, R>(
+  driver: Layer.Layer<MessageDeliveryDriver, E, R>,
+) =>
+  Layer.fromBuildMemo((memoMap, scope) =>
+    Effect.gen(function* () {
+      const context = yield* Effect.context<R>();
+      const store = yield* MessageDeliveryStore;
 
-    const failure = (operation: string) => () =>
-      DurableAlarmError.make({
-        operation,
-        message: "Durable message recovery remains pending",
-      });
+      // Failed builds release their Layer scopes; let a later wave build again.
+      const service = yield* Effect.cachedWithTTL(
+        Layer.buildWithMemoMap(driver, memoMap, scope).pipe(
+          Effect.provide(context),
+          Effect.map(Context.get(MessageDeliveryDriver)),
+          Effect.mapError((cause) =>
+            DurableAlarmError.make({
+              operation: "prepare message delivery",
+              message: "Durable message recovery remains pending",
+              cause,
+            }),
+          ),
+        ),
+        (exit) => (Exit.isSuccess(exit) ? Duration.infinity : Duration.zero),
+      );
 
-    const prepare = Effect.gen(function* () {
-      const deadline = yield* store.nextDeadline();
+      const failure = (operation: string) => () =>
+        DurableAlarmError.make({
+          operation,
+          message: "Durable message recovery remains pending",
+        });
 
-      if (deadline === null || deadline > (yield* Clock.currentTimeMillis))
-        return { timeoutMillis: 1, run: Effect.succeed(Option.fromNullishOr(deadline)) };
-      // The assembled driver has four permits: a wave is one parallel attempt window.
-      const keys = yield* store.due(yield* Clock.currentTimeMillis, 4);
-      const records = yield* Effect.forEach(keys, (key) => store.get(key));
+      const prepare = Effect.gen(function* () {
+        const deadline = yield* store.nextDeadline();
 
-      return {
-        timeoutMillis: Math.max(
-          1,
-          ...records.map((record) => record?.policy.attemptTimeoutMillis ?? 1),
-        ),
-        run: Effect.forEach(keys, (key) => driver.process(key), {
-          concurrency: 4,
-          discard: true,
-        }).pipe(
-          Effect.andThen(store.nextDeadline()),
-          Effect.map(Option.fromNullishOr),
-          Effect.mapError(failure("dispatch message delivery")),
-        ),
-      };
-    }).pipe(Effect.mapError(failure("prepare message delivery")));
+        if (deadline === null || deadline > (yield* Clock.currentTimeMillis))
+          return { timeoutMillis: 1, run: Effect.succeed(Option.fromNullishOr(deadline)) };
+        // The assembled driver has four permits: a wave is one parallel attempt window.
+        const keys = yield* store.due(yield* Clock.currentTimeMillis, 4);
+        const records = yield* Effect.forEach(keys, (key) => store.get(key));
 
-    return Context.make(ThreadMessageDelivery, {
-      prepare,
-    });
-  }),
+        return {
+          timeoutMillis: Math.max(
+            1,
+            ...records.map((record) => record?.policy.attemptTimeoutMillis ?? 1),
+          ),
+          run: Effect.flatMap(service, (driver) =>
+            Effect.forEach(keys, (key) => driver.process(key), {
+              concurrency: 4,
+              discard: true,
+            }),
+          ).pipe(
+            Effect.andThen(store.nextDeadline()),
+            Effect.map(Option.fromNullishOr),
+            Effect.mapError(failure("dispatch message delivery")),
+          ),
+        };
+      }).pipe(Effect.mapError(failure("prepare message delivery")));
+
+      return Context.make(ThreadMessageDelivery, { prepare });
+    }),
+  );
+
+/** Message progress shares the native alarm slot without blocking source runtime work. */
+export const threadMessageDeliveryLayer = lazyThreadMessageDeliveryLayer(
+  Layer.effect(MessageDeliveryDriver, MessageDeliveryDriver),
 );