@effect-agent/platform-cloudflare 0.1.0-beta.9 → 0.1.0-beta.90

package/src/{wake-scheduler.ts → WakeScheduler.ts}

@@ -1,9 +1,14 @@
-import type { ConversationId } from "@effect-agent/core";
-import { WakeScheduler } from "@effect-agent/session";
 import { Effect, Layer, PubSub, Schema, Stream } from "effect";
+import { type ThreadId } from "effect-agent/identifiers";
+import { makeWakeSubscriptionHub, WakeScheduler } from "effect-agent/wake-scheduler";
 
-import { DurableAlarmService } from "./alarm.ts";
-import { ConversationObjectIdentity, ConversationObjectNamespace } from "./bindings.ts";
+import { DurableAlarmService } from "./Alarm.ts";
+import {
+  callThreadObject,
+  ThreadObjectPlacement,
+  ThreadObjectNamespace,
+} from "./CloudflareBindings.ts";
+import { safeCauseMessage } from "./internal/boundary.ts";
 
 /**
  * Bounded in-memory wake buffer for same-incarnation `awaitSettlement` subscribers. Wake
@@ -15,7 +20,7 @@ const WAKE_BUFFER_CAPACITY = 1_024;
 
 /** A remote wake stub call failed; always swallowed and logged (hints are droppable). */
 class RemoteWakeDropped extends Schema.TaggedError<RemoteWakeDropped>()("RemoteWakeDropped", {
-  conversationId: Schema.String,
+  threadId: Schema.String,
   message: Schema.String,
   cause: Schema.optionalKey(Schema.Defect()),
 }) {}
@@ -35,17 +40,20 @@ class RemoteWakeDropped extends Schema.TaggedError<RemoteWakeDropped>()("RemoteW
 export const cloudflareWakeSchedulerLayer: Layer.Layer<
   WakeScheduler,
   never,
-  DurableAlarmService | ConversationObjectIdentity | ConversationObjectNamespace
+  DurableAlarmService | ThreadObjectPlacement | ThreadObjectNamespace
 > = Layer.effect(WakeScheduler)(
   Effect.gen(function* () {
     const alarm = yield* DurableAlarmService;
-    const identity = yield* ConversationObjectIdentity;
-    const { namespace } = yield* ConversationObjectNamespace;
-    const hints = yield* PubSub.sliding<ConversationId>(WAKE_BUFFER_CAPACITY);
+    const placement = yield* ThreadObjectPlacement;
+    const namespace = yield* ThreadObjectNamespace;
+    const hints = yield* PubSub.sliding<ThreadId>(WAKE_BUFFER_CAPACITY);
+    const progress = yield* makeWakeSubscriptionHub;
+
     yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
 
-    const notifyLocal = (conversationId: ConversationId) =>
-      PubSub.publish(hints, conversationId).pipe(
+    const notifyLocal = (threadId: ThreadId) =>
+      progress.notify(threadId).pipe(
+        Effect.andThen(PubSub.publish(hints, threadId)),
         Effect.andThen(alarm.scheduleNow),
         Effect.catch((error) =>
           // `notify` never fails by contract; a failed alarm write degrades to "hint lost"
@@ -55,30 +63,28 @@ export const cloudflareWakeSchedulerLayer: Layer.Layer<
         Effect.asVoid,
       );
 
-    const notifyRemote = (conversationId: ConversationId) =>
-      Effect.tryPromise({
-        try: () => namespace.get(namespace.idFromName(conversationId)).wake(),
-        catch: (cause) =>
+    const notifyRemote = (threadId: ThreadId) =>
+      callThreadObject(
+        threadId,
+        (target) => target.wake(),
+        (cause) =>
           RemoteWakeDropped.make({
-            conversationId,
-            message: cause instanceof Error ? cause.message : String(cause),
+            threadId,
+            message: safeCauseMessage(cause, "The remote wake failed without a diagnostic"),
             cause,
           }),
-      }).pipe(
+      ).pipe(
+        Effect.provideService(ThreadObjectNamespace, namespace),
         Effect.catch((error) =>
-          Effect.logWarning(
-            `CloudflareWakeScheduler: remote wake of ${conversationId} dropped`,
-            error,
-          ),
+          Effect.logWarning(`CloudflareWakeScheduler: remote wake of ${threadId} dropped`, error),
         ),
         Effect.asVoid,
       );
 
     return WakeScheduler.of({
-      notify: (conversationId) =>
-        conversationId === identity.conversationId
-          ? notifyLocal(conversationId)
-          : notifyRemote(conversationId),
+      notify: (threadId) =>
+        placement.ownsThread(threadId) ? notifyLocal(threadId) : notifyRemote(threadId),
+      subscribe: progress.subscribe,
       wakes: Stream.fromPubSub(hints),
     });
   }),

package/src/index.ts

@@ -1,23 +1,12 @@
-/**
- * `@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`
- * multiplex every cadence into the Object's single alarm slot (nonterminal work implies a
- * committed alarm, so eviction recovers without an incoming request), and
- * `CloudflareConversationClient` 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.
- */
-export * from "./bindings.ts";
-export * from "./config.ts";
-export * from "./alarm.ts";
-export * from "./wake-scheduler.ts";
-export * from "./transport.ts";
-export * from "./layers.ts";
-export * from "./conversation-object.ts";
-export * from "./client.ts";
-export * from "./code-mode-executor.ts";
+export * as Alarm from "./Alarm.ts";
+export * as CloudflareBindings from "./CloudflareBindings.ts";
+export * as CloudflareBrowser from "./CloudflareBrowser.ts";
+export * as CloudflareCodeMode from "./CloudflareCodeMode.ts";
+export * as CloudflareConfig from "./CloudflareConfig.ts";
+export * as CloudflareMemory from "./CloudflareMemory.ts";
+export * as CloudflareScheduling from "./CloudflareScheduling.ts";
+export * as CloudflareSubscriptions from "./CloudflareSubscriptions.ts";
+export * as CloudflareThreadClient from "./CloudflareThreadClient.ts";
+export * as ThreadObject from "./ThreadObject.ts";
+export * as WakeScheduler from "./WakeScheduler.ts";
+export * as CloudflareAiGateway from "./CloudflareAiGateway.ts";

package/src/internal/boundary.ts

@@ -0,0 +1,55 @@
+import { Predicate } from "effect";
+
+const MAX_FOREIGN_DIAGNOSTIC_LENGTH = 8_192;
+
+const boundForeignDiagnostic = (message: string): string =>
+  message.slice(0, MAX_FOREIGN_DIAGNOSTIC_LENGTH);
+
+/** Render a foreign failure without trusting accessors or coercion hooks on the value. */
+export const safeCauseMessage = (cause: unknown, fallback: string): string => {
+  try {
+    const message = cause instanceof Error ? cause.message : cause;
+
+    return boundForeignDiagnostic(typeof message === "string" ? message : String(message));
+  } catch {
+    return boundForeignDiagnostic(fallback);
+  }
+};
+
+/** Include an Error name when worker-failure classification needs it. */
+export const safeCauseDiagnostic = (cause: unknown, fallback: string): string => {
+  try {
+    return cause instanceof Error
+      ? boundForeignDiagnostic(`${cause.name}: ${cause.message}`)
+      : safeCauseMessage(cause, fallback);
+  } catch {
+    return boundForeignDiagnostic(fallback);
+  }
+};
+
+export interface CloudflareFailureSignals {
+  readonly retryable?: boolean | undefined;
+  readonly overloaded?: boolean | undefined;
+}
+
+/** Read Cloudflare RPC classifications without letting a hostile proxy defect the client. */
+export const cloudflareFailureSignals = (cause: unknown): CloudflareFailureSignals => {
+  if (!Predicate.isObjectKeyword(cause)) return {};
+  try {
+    const retryableValue = Reflect.get(cause, "retryable");
+    const overloadedValue = Reflect.get(cause, "overloaded");
+    const resetValue = Reflect.get(cause, "durableObjectReset");
+
+    const retryable =
+      typeof retryableValue === "boolean" ? retryableValue : resetValue === true ? true : undefined;
+
+    const overloaded = typeof overloadedValue === "boolean" ? overloadedValue : undefined;
+
+    return {
+      ...(retryable === undefined ? {} : { retryable }),
+      ...(overloaded === undefined ? {} : { overloaded }),
+    };
+  } catch {
+    return {};
+  }
+};