@effect-agent/platform-cloudflare 0.1.0-beta.22 → 0.1.0-beta.23

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { Cause, Clock, Context, Crypto, Deferred, Duration, Effect, Exit, Fiber, Layer, Option, PubSub, Random, Ref, Schema, Semaphore, Stream } from "effect";
+import { Clock, Context, Crypto, Deferred, Duration, Effect, Exit, Fiber, Layer, Option, PubSub, Queue, Random, Ref, Schema, Semaphore, Stream } from "effect";
 import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationRead, ConversationStore, ConversationStoreError, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeploymentId, DigestError, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, FenceRejected, IdempotencyKey, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, OwnershipLost, PersistedJson, Principal, ProducerId, Receipt, RecoveryExplanation, RecoveryReport, RetryCommand, RetryRefused, RunJournalError, Settlement, SettlementConflict, SubmissionLedger, SubmissionLookupByKey, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler, makeWakeSubscriptionHub, operationAuthorizerLayer } from "@effect-agent/session";
 import { ConversationPortTransport, DEFAULT_MAX_STORED_VALUE_BYTES, conversationStoreLayer, handleEncodedPortRequest, portTransportFailure, routedConversationStoreLayer, routedSubmissionLedgerLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer } from "@effect-agent/storage-cloudflare";
 import { AgentId, AgentInputError, ConversationId, SubmissionId } from "@effect-agent/core";
@@ -1659,143 +1659,109 @@ const makeExecute = (options) => Effect.fn("DynamicWorkerCodeExecutor.execute")(
 	let issuedHostCalls = 0;
 	let passOpen = true;
 	const queuedHostCalls = [];
-	let activeHostCall;
-	let hostDispatchFailure;
-	let propagatedHostDispatchFailure;
-	let signalHostDispatchFailure = (_failure) => void 0;
-	const hostDispatchFailureSignal = new Promise((resolve) => {
-		signalHostDispatchFailure = resolve;
-	});
+	let passFailure;
+	const failPass = (error) => {
+		if (passFailure === void 0) passFailure = error;
+	};
 	const rejectQueuedHostCalls = (reason) => {
 		for (const queued of queuedHostCalls.splice(0)) queued.reject(reason);
 	};
-	const recordHostDispatchFailure = (failure) => {
-		if (hostDispatchFailure !== void 0) return;
-		hostDispatchFailure = failure;
-		signalHostDispatchFailure(failure);
-		rejectQueuedHostCalls(/* @__PURE__ */ new Error("Code Mode pass failed"));
-	};
-	const failHostDispatch = (failure) => {
-		switch (failure._tag) {
-			case "host-call-limit": return Effect.fail(CodeHostCallLimitError.make({
+	const queue = yield* Queue.unbounded();
+	const deliverHostOutcome = (queued, outcome) => Effect.gen(function* () {
+		const decoded = decodeHostCallResult(outcome);
+		if (Option.isNone(decoded)) {
+			const error = CodeExecutionProtocolError.make({
 				implementation: dynamicWorkerImplementation,
-				limit: request.limits.maxHostCalls,
-				logs: []
-			}));
-			case "host-call-result-limit": return Effect.fail(CodeOutputLimitError.make({
+				message: "The execution host returned a value outside the CodeHostCallResult schema"
+			});
+			failPass(error);
+			return yield* error;
+		}
+		const encoded = encodeHostResultPayload(decoded.value);
+		if (encoded === void 0 || encoded.resultBytes > request.limits.maxHostCallResultBytes) {
+			const error = CodeOutputLimitError.make({
 				implementation: dynamicWorkerImplementation,
 				surface: "host-call-result",
 				limit: request.limits.maxHostCallResultBytes,
-				observed: failure.observed,
+				observed: encoded?.resultBytes ?? 0,
 				logs: []
-			}));
-			case "host-call-protocol": return Effect.fail(CodeExecutionProtocolError.make({
-				implementation: dynamicWorkerImplementation,
-				message: "The execution host returned a value outside the CodeHostCallResult schema"
-			}));
-			case "wall-clock-timeout": return Effect.fail(CodeExecutionTimeoutError.make({
-				implementation: dynamicWorkerImplementation,
-				kind: "wall-clock",
-				maxWallTime: request.limits.maxWallTime,
-				logs: []
-			}));
-			case "host-call-defect": return Effect.failCause(failure.cause);
+			});
+			failPass(error);
+			return yield* error;
 		}
-	};
-	const propagateHostDispatchFailure = (failure) => Effect.gen(function* () {
-		propagatedHostDispatchFailure = failure;
-		return yield* failHostDispatch(failure);
+		const normalizedPayload = JSON.parse(encoded.encodedPayload);
+		queued.resolve(decoded.value._tag === "CodeHostCallSuccess" ? {
+			_tag: "CodeHostCallSuccess",
+			value: normalizedPayload
+		} : {
+			_tag: "CodeHostCallFailure",
+			error: normalizedPayload
+		});
 	});
-	const startNextHostCall = () => {
-		if (!passOpen || hostDispatchFailure !== void 0 || activeHostCall !== void 0) return;
-		const queued = queuedHostCalls.shift();
-		if (queued === void 0) return;
-		const fiber = Effect.runFork(Effect.yieldNow.pipe(Effect.andThen(host.call(queued.call)), Effect.timeoutOrElse({
-			duration: remainingPassWallTime(),
-			orElse: () => Effect.sync(() => {
-				recordHostDispatchFailure({ _tag: "wall-clock-timeout" });
-				throw new Error("code-mode host call exceeded the pass wall-clock limit");
-			})
-		}), Effect.map((outcome) => {
-			const decoded = decodeHostCallResult(outcome);
-			if (Option.isNone(decoded)) {
-				recordHostDispatchFailure({ _tag: "host-call-protocol" });
-				throw new Error("host-call protocol violation");
-			}
-			const encoded = encodeHostResultPayload(decoded.value);
-			if (encoded === void 0 || encoded.resultBytes > request.limits.maxHostCallResultBytes) {
-				recordHostDispatchFailure({
-					_tag: "host-call-result-limit",
-					observed: encoded?.resultBytes ?? 0
+	const server = yield* Effect.gen(function* () {
+		while (true) {
+			const work = yield* Queue.take(queue);
+			if (work._tag === "limit") {
+				const error = CodeHostCallLimitError.make({
+					implementation: dynamicWorkerImplementation,
+					limit: request.limits.maxHostCalls,
+					logs: []
 				});
-				throw new Error("host-call result limit exceeded");
+				failPass(error);
+				return yield* error;
 			}
-			const normalizedPayload = JSON.parse(encoded.encodedPayload);
-			return decoded.value._tag === "CodeHostCallSuccess" ? {
-				_tag: "CodeHostCallSuccess",
-				value: normalizedPayload
-			} : {
-				_tag: "CodeHostCallFailure",
-				error: normalizedPayload
-			};
-		})));
-		activeHostCall = {
-			fiber,
-			settlement: Effect.runPromise(Fiber.await(fiber)).then((exit) => {
-				if (Exit.isSuccess(exit)) {
-					queued.resolve(exit.value);
-					return;
+			const queued = work.queued;
+			yield* host.call(queued.call).pipe(Effect.timeoutOrElse({
+				duration: remainingPassWallTime(),
+				orElse: () => {
+					const error = CodeExecutionTimeoutError.make({
+						implementation: dynamicWorkerImplementation,
+						kind: "wall-clock",
+						maxWallTime: request.limits.maxWallTime,
+						logs: []
+					});
+					failPass(error);
+					return error;
 				}
-				if (!Cause.hasInterruptsOnly(exit.cause)) recordHostDispatchFailure({
-					_tag: "host-call-defect",
-					cause: exit.cause
-				});
-				queued.reject(/* @__PURE__ */ new Error("Code Mode host call failed"));
-			}).finally(() => {
-				if (activeHostCall?.fiber === fiber) activeHostCall = void 0;
-				startNextHostCall();
-			})
-		};
-	};
+			}), Effect.flatMap((outcome) => deliverHostOutcome(queued, outcome)), Effect.tapError(() => Effect.sync(() => queued.reject(/* @__PURE__ */ new Error("Code Mode host call failed")))), Effect.onInterrupt(() => Effect.sync(() => queued.reject(/* @__PURE__ */ new Error("Code Mode pass is closing")))));
+		}
+	}).pipe(Effect.forkScoped);
 	const dispatch = (hostCall) => {
 		if (!passOpen) return Promise.reject(/* @__PURE__ */ new Error("Code Mode pass is closing"));
 		issuedHostCalls += 1;
 		if (issuedHostCalls > request.limits.maxHostCalls) {
-			recordHostDispatchFailure({ _tag: "host-call-limit" });
+			const error = CodeHostCallLimitError.make({
+				implementation: dynamicWorkerImplementation,
+				limit: request.limits.maxHostCalls,
+				logs: []
+			});
+			failPass(error);
+			Queue.offerUnsafe(queue, { _tag: "limit" });
 			return Promise.reject(/* @__PURE__ */ new Error("host-call limit exceeded"));
 		}
 		const decoded = decodeHostCall(hostCall);
 		if (Option.isNone(decoded)) return Promise.reject(/* @__PURE__ */ new TypeError("host calls must match the CodeHostCall schema"));
 		return new Promise((resolve, reject) => {
-			queuedHostCalls.push({
+			const queued = {
 				call: decoded.value,
 				resolve,
 				reject
+			};
+			queuedHostCalls.push(queued);
+			Queue.offerUnsafe(queue, {
+				_tag: "call",
+				queued
 			});
-			startNextHostCall();
 		});
 	};
-	const closeHostDispatch = Effect.gen(function* () {
+	const closeAdmission = Effect.sync(() => {
 		passOpen = false;
 		passRegistry.delete(passId);
 		rejectQueuedHostCalls(/* @__PURE__ */ new Error("Code Mode pass is closing"));
-		const active = activeHostCall;
-		if (active !== void 0) {
-			yield* Fiber.interrupt(active.fiber);
-			yield* Effect.promise(() => active.settlement);
-			if (activeHostCall === active) activeHostCall = void 0;
-		}
-		return hostDispatchFailure;
 	});
-	const stopHostDispatch = closeHostDispatch.pipe(Effect.flatMap((failure) => failure !== void 0 && propagatedHostDispatchFailure !== failure ? propagateHostDispatchFailure(failure) : Effect.void));
-	const releaseHostDispatch = closeHostDispatch.pipe(Effect.flatMap((failure) => {
-		if (failure?._tag !== "host-call-defect" || propagatedHostDispatchFailure === failure) return Effect.void;
-		propagatedHostDispatchFailure = failure;
-		return Effect.failCause(failure.cause);
-	}));
 	yield* Effect.acquireRelease(Effect.sync(() => {
 		passRegistry.set(passId, { dispatch });
-	}), () => releaseHostDispatch);
+	}), () => closeAdmission.pipe(Effect.andThen(Fiber.interrupt(server))));
 	const workerCode = {
 		compatibilityDate: options.compatibilityDate ?? "2025-05-01",
 		mainModule: "harness.js",
@@ -1849,7 +1815,7 @@ const makeExecute = (options) => Effect.fn("DynamicWorkerCodeExecutor.execute")(
 		},
 		catch: (cause) => classifyWorkerFailure(cause, request.limits.maxWallTime)
 	});
-	const raw = yield* Effect.raceFirst(rpc.pipe(Effect.timeoutOrElse({
+	const exit = yield* Effect.raceFirst(rpc.pipe(Effect.timeoutOrElse({
 		duration: remainingPassWallTime(),
 		orElse: () => CodeExecutionTimeoutError.make({
 			implementation: dynamicWorkerImplementation,
@@ -1857,10 +1823,13 @@ const makeExecute = (options) => Effect.fn("DynamicWorkerCodeExecutor.execute")(
 			maxWallTime: request.limits.maxWallTime,
 			logs: []
 		})
-	})), Effect.promise(() => hostDispatchFailureSignal).pipe(Effect.flatMap(propagateHostDispatchFailure)));
-	yield* stopHostDispatch;
+	})), Fiber.join(server)).pipe(Effect.exit);
+	yield* closeAdmission;
+	yield* Fiber.interrupt(server);
+	if (passFailure !== void 0) return yield* passFailure;
+	if (Exit.isFailure(exit)) return yield* Effect.failCause(exit.cause);
+	const raw = exit.value;
 	const finishedAt = performance.now();
-	if (hostDispatchFailure !== void 0) return yield* propagateHostDispatchFailure(hostDispatchFailure);
 	const outcome = decodeHarnessOutcome(raw);
 	if (Option.isNone(outcome)) return yield* CodeExecutionProtocolError.make({
 		implementation: dynamicWorkerImplementation,