@effect-agent/platform-cloudflare 0.1.0-beta.12 → 0.1.0-beta.13

package/dist/index.d.mts

@@ -594,14 +594,6 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
       readonly createdAt: string;
       readonly deploymentId: string;
       readonly payload: {
-        readonly _tag: "SubagentStarted";
-        readonly runId: string;
-        readonly toolCallId: string;
-        readonly childConversationId: string;
-        readonly childSubmissionId: string;
-        readonly childReceiptId: string;
-        readonly childRunId: string;
-      } | {
         readonly _tag: "ToolCallPrepared";
         readonly runId: string;
         readonly turnId: string;
@@ -637,6 +629,14 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly submissionId: string;
         readonly author: string;
         readonly reason: string;
+      } | {
+        readonly _tag: "SubagentStarted";
+        readonly runId: string;
+        readonly toolCallId: string;
+        readonly childConversationId: string;
+        readonly childSubmissionId: string;
+        readonly childReceiptId: string;
+        readonly childRunId: string;
       } | {
         readonly _tag: "ConversationCreated";
         readonly agentId: string;
@@ -717,6 +717,8 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly runId?: string | undefined;
         readonly result?: Schema.Json | undefined;
         readonly finishReason?: "budget-exhausted" | undefined;
+        readonly exhausted?: "tokens" | "tool-calls" | "turns" | undefined;
+        readonly policyLimit?: "cost" | "duration" | "repeated-failures" | "tokens" | "tool-calls" | "turns" | "usage" | undefined;
       } | {
         readonly _tag: "SubagentRequested";
         readonly runId: string;

package/dist/index.mjs

@@ -1,11 +1,11 @@
-import { Clock, Context, Duration, Effect, Fiber, Layer, Option, PubSub, Random, Ref, Schema, Stream } from "effect";
+import { Cause, Clock, Context, Duration, Effect, Exit, Fiber, Layer, Option, PubSub, Random, Ref, Schema, 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 } 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";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
 import { DurableObject, DurableObjectState, WorkerEnvironment } from "effect-cf";
-import { CodeExecutionHost, CodeExecutionProtocolError, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallLimitError, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, SandboxImplementation } from "@effect-agent/sandbox";
+import { CodeExecutionHost, CodeExecutionProtocolError, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallLimitError, CodeHostCallResult, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, SandboxImplementation } from "@effect-agent/sandbox";
 import { WorkerEntrypoint } from "cloudflare:workers";
 //#region src/bindings.ts
 /**
@@ -1348,19 +1348,25 @@ const decodeHostCall = (value) => {
 		return Option.none();
 	}
 };
-/**
-* Project a host outcome to the plain JSON envelope the harness reads. A
-* `CodeExecutionHost` may return either real `CodeHostCallResult` instances
-* (the substitute and conformance kit) or plain-object equivalents (the Code
-* Mode capability's broker route), so this reads the shared fields rather than
-* `Schema.encodeSync`, which would reject a plain object.
-*/
-const hostResultEnvelope = (outcome) => outcome._tag === "CodeHostCallSuccess" ? {
-	_tag: "CodeHostCallSuccess",
-	value: outcome.value
-} : {
-	_tag: "CodeHostCallFailure",
-	error: outcome.error
+const decodeHostCallResult = (value) => {
+	try {
+		return Schema.decodeUnknownOption(CodeHostCallResult)(value);
+	} catch {
+		return Option.none();
+	}
+};
+const encodeHostResultPayload = (outcome) => {
+	try {
+		const payload = outcome._tag === "CodeHostCallSuccess" ? outcome.value : outcome.error;
+		const encodedPayload = JSON.stringify(payload);
+		if (encodedPayload === void 0) return void 0;
+		return {
+			encodedPayload,
+			resultBytes: utf8ByteLength(encodedPayload)
+		};
+	} catch {
+		return;
+	}
 };
 const utf8ByteLength = (value) => {
 	let total = 0;
@@ -1370,14 +1376,6 @@ const utf8ByteLength = (value) => {
 	}
 	return total;
 };
-const encodedJsonByteLength = (value) => {
-	try {
-		const encoded = JSON.stringify(value);
-		return encoded === void 0 ? void 0 : utf8ByteLength(encoded);
-	} catch {
-		return;
-	}
-};
 /** Reserved global names the harness owns inside the dynamic worker. */
 const reservedHarnessGlobals = /* @__PURE__ */ new Set(["console"]);
 const passCounterState = { next: 0 };
@@ -1401,67 +1399,149 @@ const makeExecute = (options) => Effect.fn("DynamicWorkerCodeExecutor.execute")(
 	const host = yield* CodeExecutionHost;
 	passCounterState.next += 1;
 	const passId = `code-mode-pass-${passCounterState.next}-${crypto.randomUUID()}`;
-	const pending = [];
-	let wake;
+	const startedAt = performance.now();
+	const passDeadline = startedAt + Duration.toMillis(request.limits.maxWallTime);
+	const remainingPassWallTime = () => Duration.millis(Math.max(0, passDeadline - performance.now()));
 	let issuedHostCalls = 0;
-	const dispatch = (hostCall) => new Promise((resolve, reject) => {
-		issuedHostCalls += 1;
-		if (issuedHostCalls > request.limits.maxHostCalls + 1) {
-			reject(/* @__PURE__ */ new Error("host-call limit exceeded"));
-			return;
-		}
-		pending.push({
-			hostCall,
-			resolve,
-			reject
-		});
-		wake?.();
-	});
-	yield* Effect.acquireRelease(Effect.sync(() => {
-		passRegistry.set(passId, { dispatch });
-	}), () => Effect.sync(() => {
-		passRegistry.delete(passId);
-	}));
-	const nextPending = Effect.suspend(() => {
-		const item = pending.shift();
-		if (item !== void 0) return Effect.succeed(item);
-		return Effect.callback((resume) => {
-			wake = () => {
-				wake = void 0;
-				const next = pending.shift();
-				if (next !== void 0) resume(Effect.succeed(next));
-			};
-		});
+	let passOpen = true;
+	const queuedHostCalls = [];
+	let activeHostCall;
+	let hostDispatchFailure;
+	let propagatedHostDispatchFailure;
+	let signalHostDispatchFailure = (_failure) => void 0;
+	const hostDispatchFailureSignal = new Promise((resolve) => {
+		signalHostDispatchFailure = resolve;
 	});
-	const serveHostCalls = Effect.gen(function* () {
-		let served = 0;
-		while (true) {
-			const item = yield* nextPending;
-			served += 1;
-			if (served > request.limits.maxHostCalls) return yield* CodeHostCallLimitError.make({
+	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({
 				implementation: dynamicWorkerImplementation,
 				limit: request.limits.maxHostCalls,
 				logs: []
-			});
-			const decoded = decodeHostCall(item.hostCall);
+			}));
+			case "host-call-result-limit": return Effect.fail(CodeOutputLimitError.make({
+				implementation: dynamicWorkerImplementation,
+				surface: "host-call-result",
+				limit: request.limits.maxHostCallResultBytes,
+				observed: failure.observed,
+				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);
+		}
+	};
+	const propagateHostDispatchFailure = (failure) => Effect.gen(function* () {
+		propagatedHostDispatchFailure = failure;
+		return yield* failHostDispatch(failure);
+	});
+	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)) {
-				item.reject(/* @__PURE__ */ new TypeError("host calls must match the CodeHostCall schema"));
-				continue;
+				recordHostDispatchFailure({ _tag: "host-call-protocol" });
+				throw new Error("host-call protocol violation");
 			}
-			const outcome = yield* host.call(decoded.value);
-			if (outcome._tag === "CodeHostCallSuccess") {
-				const bytes = encodedJsonByteLength(outcome.value);
-				if (bytes === void 0 || bytes > request.limits.maxHostCallResultBytes) return yield* CodeOutputLimitError.make({
-					implementation: dynamicWorkerImplementation,
-					surface: "host-call-result",
-					limit: request.limits.maxHostCallResultBytes,
-					observed: bytes ?? 0,
-					logs: []
+			const encoded = encodeHostResultPayload(decoded.value);
+			if (encoded === void 0 || encoded.resultBytes > request.limits.maxHostCallResultBytes) {
+				recordHostDispatchFailure({
+					_tag: "host-call-result-limit",
+					observed: encoded?.resultBytes ?? 0
 				});
+				throw new Error("host-call result limit exceeded");
 			}
-			item.resolve(hostResultEnvelope(outcome));
+			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;
+				}
+				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();
+			})
+		};
+	};
+	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" });
+			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({
+				call: decoded.value,
+				resolve,
+				reject
+			});
+			startNextHostCall();
+		});
+	};
+	const closeHostDispatch = Effect.gen(function* () {
+		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);
 	const workerCode = {
 		compatibilityDate: options.compatibilityDate ?? "2025-05-01",
 		allowExperimental: true,
@@ -1492,7 +1572,6 @@ const makeExecute = (options) => Effect.fn("DynamicWorkerCodeExecutor.execute")(
 			subRequests: request.limits.maxHostCalls + 8
 		} }
 	};
-	const startedAt = yield* Clock.currentTimeMillis;
 	const worker = yield* Effect.acquireRelease(Effect.try({
 		try: () => options.loader.load(workerCode),
 		catch: (cause) => {
@@ -1511,23 +1590,24 @@ const makeExecute = (options) => Effect.fn("DynamicWorkerCodeExecutor.execute")(
 	}), (stub) => Effect.sync(() => {
 		stub[Symbol.dispose]?.();
 	}));
-	const server = yield* serveHostCalls.pipe(Effect.forkScoped);
 	const rpc = Effect.tryPromise({
 		try: async () => {
 			return await worker.getEntrypoint().run();
 		},
 		catch: (cause) => classifyWorkerFailure(cause, request.limits.maxWallTime)
 	});
-	const raw = yield* Effect.raceFirst(rpc, Fiber.join(server)).pipe(Effect.timeoutOrElse({
-		duration: request.limits.maxWallTime,
+	const raw = yield* Effect.raceFirst(rpc.pipe(Effect.timeoutOrElse({
+		duration: remainingPassWallTime(),
 		orElse: () => CodeExecutionTimeoutError.make({
 			implementation: dynamicWorkerImplementation,
 			kind: "wall-clock",
 			maxWallTime: request.limits.maxWallTime,
 			logs: []
 		})
-	}), Effect.ensuring(Fiber.interrupt(server)));
-	const finishedAt = yield* Clock.currentTimeMillis;
+	})), Effect.promise(() => hostDispatchFailureSignal).pipe(Effect.flatMap(propagateHostDispatchFailure)));
+	yield* stopHostDispatch;
+	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,