@yielded/agent-platform-cloudflare 0.1.0-beta.166 → 0.1.0-beta.168

package/dist/CloudflareThreadClient-CZm0TvUe.mjs

@@ -0,0 +1,588 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { ThreadObjectNamespace, callThreadObject } from "./CloudflareBindings.mjs";
+import { AdmissionLimitExceeded } from "./CloudflareConfig.mjs";
+import { r as safeCauseMessage, t as cloudflareFailureSignals } from "./boundary-BguazVkh.mjs";
+import { n as DurableAlarmError } from "./Alarm-DxODgAZZ.mjs";
+import { Receipt } from "@yielded/agent/durable-agent-runtime";
+import { AgentId, ThreadId } from "@yielded/agent/identifiers";
+import { AbortCommand, AbortIntent, AdmissionConflict, AdmissionFence, AdmissionGroup, AdmissionPolicyError, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, IdempotencyKey, JoinedToHost, LedgerError, OwnershipLost, Principal, Settlement, SettlementConflict, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent } from "@yielded/agent/submission-ledger";
+import { Context, Crypto, Duration, Effect, Layer, PlatformError, Predicate, Schema, Stream } from "effect";
+import { RpcTargets, RpcTracing } from "effect-cf";
+import { CanonicalRecordEnvelope, CanonicalSequence, DefinitionDigests, PersistedJson, SubmissionSettledRecord, WorkerAdmission } from "@yielded/agent/records";
+import { AgentInputError } from "@yielded/agent/agent-error";
+import { DigestError } from "@yielded/agent/digest";
+import { DurableRuntimeFailpointError } from "@yielded/agent/durable-failpoint";
+import { InputMessage } from "@yielded/agent/messaging";
+import { OperationDenied } from "@yielded/agent/operation-authorizer";
+import { SubmissionStatus } from "@yielded/agent/submission-status";
+import { AppendConflict, ThreadNotMaterialized, ThreadStoreError } from "@yielded/agent/thread-store";
+import { createHash } from "node:crypto";
+import { BrowserCrypto } from "@effect/platform-browser";
+import { Event } from "@yielded/agent/provisional-text";
+//#region src/internal/crypto.ts
+/** Workers use native SHA-256 while retaining BrowserCrypto's services and overrides. */
+const cloudflareCryptoLayer = Layer.effect(Crypto.Crypto, Effect.gen(function* () {
+	const base = yield* Crypto.Crypto;
+	const webCrypto = yield* BrowserCrypto.WebCrypto;
+	const hostGlobals = globalThis;
+	return Crypto.Crypto.of({
+		...base,
+		digest: (algorithm, data) => {
+			if (algorithm !== "SHA-256" || !("crypto" in hostGlobals) || webCrypto !== hostGlobals.crypto || typeof webCrypto.subtle?.digest !== "function") return base.digest(algorithm, data);
+			return Effect.try({
+				try: () => Uint8Array.from(createHash("sha256").update(new Uint8Array(data)).digest()),
+				catch: (cause) => PlatformError.systemError({
+					module: "Crypto",
+					method: "digest",
+					_tag: "Unknown",
+					description: "Could not compute digest",
+					cause
+				})
+			});
+		}
+	});
+})).pipe(Layer.provide(BrowserCrypto.layer));
+//#endregion
+//#region src/internal/live-text-protocol.ts
+const MAX_FRAME_BYTES = 32768;
+const MAX_DELTA_LENGTH = 4096;
+const MAX_DRAFT_LENGTH = 2097152;
+const streamId = Schema.NonEmptyString.check(Schema.isMaxLength(256));
+const Request = Schema.Struct({ schemaVersion: Schema.Literal(1) });
+/**
+* Reset replaces all drafts with a snapshot, streamed as native Text parts before live deltas.
+* Each snapshot starts a fresh streamId. Its sequences are unrelated to canonical sequences.
+*/
+const Frame = Schema.Union([Schema.TaggedStruct("Reset", {
+	schemaVersion: Schema.Literal(1),
+	streamId,
+	threadId: ThreadId,
+	sequence: Schema.Literal(0)
+}), Schema.TaggedStruct("Event", {
+	schemaVersion: Schema.Literal(1),
+	streamId,
+	sequence: Schema.Int.check(Schema.isGreaterThan(0)),
+	event: Event
+})]);
+/** Bounds are checked before queueing; provider metadata is deliberately absent. */
+const isBoundedEvent = (event) => {
+	const ids = [
+		event.threadId,
+		event.submissionId,
+		event.attemptId
+	];
+	if (event._tag !== "AttemptEnded") ids.push(event.runId, event.turnId);
+	if (ids.some((id) => id.length > 256)) return false;
+	return event._tag !== "Text" || event.part.id.length <= 256 && Object.keys(event.part.metadata).length === 0 && (event.part.type !== "text-delta" || event.part.delta.length <= 4096);
+};
+//#endregion
+//#region src/CloudflareThreadClient.ts
+var CloudflareThreadClient_exports = /* @__PURE__ */ __exportAll({
+	AbortRecorded: () => AbortRecorded,
+	ApprovalRecorded: () => ApprovalRecorded,
+	AwaitProgressRequest: () => AwaitProgressRequest,
+	CancelProgressRequest: () => CancelProgressRequest,
+	CloudflareThreadClient: () => CloudflareThreadClient,
+	HostFailed: () => HostFailed,
+	HostFailure: () => HostFailure,
+	HostProtocolError: () => HostProtocolError,
+	HostResponse: () => HostResponse,
+	LiveTextFrame: () => Frame,
+	ObservePageRequest: () => ObservePageRequest,
+	ObservedPage: () => ObservedPage,
+	ProgressCancelled: () => ProgressCancelled,
+	ProgressObserved: () => ProgressObserved,
+	SettlementReached: () => SettlementReached,
+	SettlementRecordReached: () => SettlementRecordReached,
+	SubmissionStatusResponse: () => SubmissionStatusResponse,
+	SubmitRequest: () => SubmitRequest,
+	SubmitSucceeded: () => SubmitSucceeded,
+	ThreadClientError: () => ThreadClientError,
+	UnknownResolutionRecorded: () => UnknownResolutionRecorded,
+	boundHostDiagnostic: () => boundHostDiagnostic,
+	decodeAbortCommand: () => decodeAbortCommand,
+	decodeApprovalDecisionCommand: () => decodeApprovalDecisionCommand,
+	decodeAwaitProgressRequest: () => decodeAwaitProgressRequest,
+	decodeCancelProgressRequest: () => decodeCancelProgressRequest,
+	decodeHostResponse: () => decodeHostResponse,
+	decodeObservePageRequest: () => decodeObservePageRequest,
+	decodeReceipt: () => decodeReceipt,
+	decodeSubmitRequest: () => decodeSubmitRequest,
+	decodeUnknownResolutionCommand: () => decodeUnknownResolutionCommand,
+	encodeAbortCommand: () => encodeAbortCommand,
+	encodeApprovalDecisionCommand: () => encodeApprovalDecisionCommand,
+	encodeAwaitProgressRequest: () => encodeAwaitProgressRequest,
+	encodeCancelProgressRequest: () => encodeCancelProgressRequest,
+	encodeHostResponse: () => encodeHostResponse,
+	encodeObservePageRequest: () => encodeObservePageRequest,
+	encodeReceipt: () => encodeReceipt,
+	encodeSubmitRequest: () => encodeSubmitRequest,
+	encodeUnknownResolutionCommand: () => encodeUnknownResolutionCommand
+});
+/**
+* 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
+* failures travel as their own tagged classes and RE-DECODE to identical tags on the caller
+* (error-tag fidelity), and protocol anomalies are answered typed instead of thrown.
+*/
+/** Ceiling for host protocol diagnostic strings. */
+const MAX_HOST_DIAGNOSTIC_LENGTH = 4096;
+const PROGRESS_CANCELLATION_TIMEOUT = "1 second";
+const BoundedDiagnostic = Schema.String.check(Schema.isMaxLength(MAX_HOST_DIAGNOSTIC_LENGTH));
+/** Truncate a diagnostic string to the host protocol's bounded length. */
+const boundHostDiagnostic = (value) => value.length > MAX_HOST_DIAGNOSTIC_LENGTH ? `${value.slice(0, 4093)}...` : value;
+/**
+* The envelope itself could not be honored: the Object could not decode the request, or a
+* response could not be encoded/decoded. Never carries operation semantics.
+*/
+var HostProtocolError = class extends Schema.TaggedError()("HostProtocolError", { message: BoundedDiagnostic }) {};
+/** The Worker-side stub call itself failed (RPC rejection, overload, eviction mid-call). */
+var ThreadClientError = class extends Schema.TaggedError()("ThreadClientError", {
+	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. */
+	retryable: Schema.optionalKey(Schema.Boolean),
+	/** Cloudflare overloads are surfaced immediately instead of adding retry pressure. */
+	overloaded: Schema.optionalKey(Schema.Boolean)
+}) {};
+/**
+* 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
+* Thread identity is deliberately absent — the addressed Object IS the lane.
+*/
+var SubmitRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/SubmitRequest")({
+	agentId: AgentId,
+	principal: Principal,
+	idempotencyKey: IdempotencyKey,
+	admissionGroup: Schema.optionalKey(AdmissionGroup),
+	admissionFence: Schema.optionalKey(AdmissionFence),
+	workerAdmission: Schema.optionalKey(WorkerAdmission),
+	messageAdmission: Schema.optionalKey(InputMessage),
+	definitions: DefinitionDigests,
+	inputPayload: PersistedJson
+}) {};
+/** One bounded page of canonical records after an optional sequence. */
+var ObservePageRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/ObservePageRequest")({
+	afterSequence: Schema.optionalKey(CanonicalSequence),
+	limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1024))
+}) {};
+/** One event-driven wait for canonical progress strictly after this sequence. */
+var AwaitProgressRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/AwaitProgressRequest")({
+	afterSequence: CanonicalSequence,
+	waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256))
+}) {};
+/** Best-effort cancellation of one in-flight progress RPC. */
+var CancelProgressRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/CancelProgressRequest")({ waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)) }) {};
+/**
+* Every typed failure a host entry point can produce, plus the protocol's own errors. Same
+* closed-union discipline as the WP2 `PortFailure`: members re-decode to the SAME tagged
+* classes on the Worker side; `cause` chains travel as Schema defects without instance
+* fidelity (plan §2.8).
+*/
+const HostFailure = Schema.Union([
+	AgentInputError,
+	DigestError,
+	AdmissionConflict,
+	AdmissionPolicyError,
+	SettlementConflict,
+	ApprovalConflict,
+	UnknownResolutionConflict,
+	JoinedToHost,
+	LedgerError,
+	OwnershipLost,
+	ThreadStoreError,
+	ThreadNotMaterialized,
+	AppendConflict,
+	DurableRuntimeFailpointError,
+	AdmissionLimitExceeded,
+	DurableAlarmError,
+	OperationDenied,
+	HostProtocolError
+]);
+var SubmitSucceeded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SubmitSucceeded")("SubmitSucceeded", { receipt: Receipt }) {};
+var SubmissionStatusResponse = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SubmissionStatusResponse")("SubmissionStatusResponse", { status: SubmissionStatus }) {};
+var SettlementReached = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SettlementReached")("SettlementReached", { settlement: Settlement }) {};
+/** The exact canonical record of an operationally finalized Submission. */
+var SettlementRecordReached = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SettlementRecordReached")("SettlementRecordReached", { record: SubmissionSettledRecord }) {};
+var ObservedPage = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ObservedPage")("ObservedPage", { records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1024)) }) {};
+/** A record was already committed or an incarnation-local hint says the caller should re-read. */
+var ProgressObserved = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ProgressObserved")("ProgressObserved", {}) {};
+var ProgressCancelled = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ProgressCancelled")("ProgressCancelled", {}) {};
+var AbortRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/AbortRecorded")("AbortRecorded", { intent: AbortIntent }) {};
+var ApprovalRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ApprovalRecorded")("ApprovalRecorded", { intent: ApprovalDecisionIntent }) {};
+var UnknownResolutionRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/UnknownResolutionRecorded")("UnknownResolutionRecorded", { intent: UnknownResolutionIntent }) {};
+/** The entry point failed TYPED on the Object; the failure re-decodes verbatim. */
+var HostFailed = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/HostFailed")("HostFailed", { failure: HostFailure }) {};
+/** The uniform answer of one host entry point. Callers narrow by the tag their call implies. */
+const HostResponse = Schema.Union([
+	SubmitSucceeded,
+	SettlementReached,
+	SettlementRecordReached,
+	SubmissionStatusResponse,
+	ObservedPage,
+	ProgressObserved,
+	ProgressCancelled,
+	AbortRecorded,
+	ApprovalRecorded,
+	UnknownResolutionRecorded,
+	HostFailed
+]);
+const decodeSubmitRequest = Schema.decodeUnknownEffect(SubmitRequest);
+const encodeSubmitRequest = Schema.encodeEffect(SubmitRequest);
+const decodeReceipt = Schema.decodeUnknownEffect(Receipt);
+const encodeReceipt = Schema.encodeEffect(Receipt);
+const decodeObservePageRequest = Schema.decodeUnknownEffect(ObservePageRequest);
+const encodeObservePageRequest = Schema.encodeEffect(ObservePageRequest);
+const decodeAwaitProgressRequest = Schema.decodeUnknownEffect(AwaitProgressRequest);
+const encodeAwaitProgressRequest = Schema.encodeEffect(AwaitProgressRequest);
+const decodeCancelProgressRequest = Schema.decodeUnknownEffect(CancelProgressRequest);
+const encodeCancelProgressRequest = Schema.encodeEffect(CancelProgressRequest);
+const decodeAbortCommand = Schema.decodeUnknownEffect(AbortCommand);
+const encodeAbortCommand = Schema.encodeEffect(AbortCommand);
+const decodeApprovalDecisionCommand = Schema.decodeUnknownEffect(ApprovalDecisionCommand);
+const encodeApprovalDecisionCommand = Schema.encodeEffect(ApprovalDecisionCommand);
+const decodeUnknownResolutionCommand = Schema.decodeUnknownEffect(UnknownResolutionCommand);
+const encodeUnknownResolutionCommand = Schema.encodeEffect(UnknownResolutionCommand);
+const encodeHostResponse = Schema.encodeEffect(HostResponse);
+const decodeHostResponse = Schema.decodeUnknownEffect(HostResponse);
+/** Failure surface of `CloudflareThreadClient.submit`. */
+const ClientSubmitHostFailure = Schema.Union([
+	AgentInputError,
+	DigestError,
+	AdmissionConflict,
+	AdmissionPolicyError,
+	LedgerError,
+	OwnershipLost,
+	ThreadStoreError,
+	ThreadNotMaterialized,
+	AppendConflict,
+	DurableRuntimeFailpointError,
+	AdmissionLimitExceeded,
+	DurableAlarmError,
+	HostProtocolError
+]);
+const ClientAwaitHostFailure = Schema.Union([
+	LedgerError,
+	OwnershipLost,
+	SettlementConflict,
+	OperationDenied,
+	HostProtocolError
+]);
+const ClientObserveHostFailure = Schema.Union([
+	ThreadStoreError,
+	ThreadNotMaterialized,
+	OperationDenied,
+	HostProtocolError
+]);
+const ClientAbortHostFailure = Schema.Union([
+	OperationDenied,
+	LedgerError,
+	OwnershipLost,
+	SettlementConflict,
+	JoinedToHost,
+	DurableRuntimeFailpointError,
+	DurableAlarmError,
+	HostProtocolError
+]);
+const ClientApprovalHostFailure = Schema.Union([
+	LedgerError,
+	OwnershipLost,
+	SettlementConflict,
+	ApprovalConflict,
+	OperationDenied,
+	DurableAlarmError,
+	HostProtocolError
+]);
+const ClientUnknownHostFailure = Schema.Union([
+	LedgerError,
+	OwnershipLost,
+	SettlementConflict,
+	UnknownResolutionConflict,
+	JoinedToHost,
+	DurableRuntimeFailpointError,
+	OperationDenied,
+	DurableAlarmError,
+	HostProtocolError
+]);
+const liveTextProtocolFailure = () => HostProtocolError.make({ message: "Provisional text is incomplete or invalid; discard drafts and read canonical records" });
+const decodeLiveText = (threadId, source) => Stream.suspend(() => {
+	const decoder = new TextDecoder("utf-8", {
+		fatal: true,
+		ignoreBOM: false
+	});
+	const decode = Schema.decodeUnknownSync(Schema.fromJsonString(Frame));
+	let pending = "";
+	let pendingBytes = 0;
+	let expected = 0;
+	let streamId;
+	const models = /* @__PURE__ */ new Map();
+	const accept = (frame) => {
+		if (frame._tag === "Reset") {
+			if (frame.streamId === streamId || frame.threadId !== threadId) throw liveTextProtocolFailure();
+			streamId = frame.streamId;
+			expected = 1;
+			models.clear();
+			return true;
+		}
+		if (streamId === void 0 || frame.streamId !== streamId || frame.sequence !== expected++ || frame.event.threadId !== threadId || !isBoundedEvent(frame.event)) throw liveTextProtocolFailure();
+		const event = frame.event;
+		if (event._tag === "AttemptEnded") {
+			for (const [key, model] of models) if (model.attemptId === event.attemptId) models.delete(key);
+			return true;
+		}
+		const key = JSON.stringify([
+			event.attemptId,
+			event.runId,
+			event.turnId,
+			event.generation
+		]);
+		if (event._tag === "Discard") {
+			models.delete(key);
+			return true;
+		}
+		let model = models.get(key);
+		if (event.part.type === "text-start") {
+			if (model?.parts.has(event.part.id)) throw liveTextProtocolFailure();
+			if ([...models.values()].reduce((size, value) => size + value.parts.size, 0) >= 32) throw liveTextProtocolFailure();
+			if (model === void 0) {
+				model = {
+					attemptId: event.attemptId,
+					parts: /* @__PURE__ */ new Set()
+				};
+				models.set(key, model);
+			}
+			model.parts.add(event.part.id);
+			return true;
+		}
+		if (!model?.parts.has(event.part.id)) throw liveTextProtocolFailure();
+		if (event.part.type === "text-end") {
+			model.parts.delete(event.part.id);
+			if (model.parts.size === 0) models.delete(key);
+		}
+		return true;
+	};
+	return Stream.fromReadableStream({
+		evaluate: () => source,
+		releaseLockOnEnd: true,
+		onError: (cause) => ThreadClientError.make({
+			threadId,
+			message: "Provisional text disconnected; discard drafts and read canonical records",
+			cause
+		})
+	}).pipe(Stream.mapEffect((chunk) => Effect.try({
+		try: () => {
+			if (!(chunk instanceof Uint8Array)) throw liveTextProtocolFailure();
+			const frames = [];
+			for (let offset = 0; offset < chunk.byteLength;) {
+				const newline = chunk.indexOf(10, offset);
+				const end = newline < 0 ? chunk.byteLength : newline;
+				pendingBytes += end - offset;
+				if (pendingBytes > 32768) throw liveTextProtocolFailure();
+				pending += decoder.decode(chunk.subarray(offset, end), { stream: newline < 0 });
+				offset = end + 1;
+				if (newline < 0) break;
+				const frame = decode(pending);
+				pending = "";
+				pendingBytes = 0;
+				if (accept(frame)) frames.push(frame);
+			}
+			return frames;
+		},
+		catch: liveTextProtocolFailure
+	})), Stream.flatMap(Stream.fromArray), Stream.concat(Stream.fail(liveTextProtocolFailure())));
+});
+const outOfContract = (threadId, operation, observed) => ThreadClientError.make({
+	threadId,
+	message: boundHostDiagnostic(`The Thread Object answered ${operation} with the out-of-contract ${observed}.`)
+});
+const hostRpcMethods = {
+	submit: "submitEncoded",
+	awaitSettlement: "awaitSettlementEncoded",
+	awaitSettlementRecord: "awaitSettlementRecordEncoded",
+	submissionStatus: "submissionStatusEncoded",
+	awaitProgress: "awaitProgressEncoded",
+	cancelProgress: "cancelProgressEncoded",
+	observePage: "observePage",
+	abort: "abortEncoded",
+	resolveApproval: "resolveApprovalEncoded",
+	resolveUnknown: "resolveUnknownEncoded"
+};
+/** Worker-side client over the Thread Object namespace (DEPLOY-010). */
+var CloudflareThreadClient = class CloudflareThreadClient extends Context.Service()("@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) {
+		return CloudflareThreadClient.layer.pipe(Layer.provide([ThreadObjectNamespace.layer(options.namespace, options), cloudflareCryptoLayer]));
+	}
+	static layer = Layer.effect(CloudflareThreadClient)(Effect.gen(function* () {
+		const namespace = yield* ThreadObjectNamespace;
+		const { rpcTracing } = namespace;
+		const crypto = yield* Crypto.Crypto;
+		const call = Effect.fnUntraced(function* (threadId, operation, encoded) {
+			const traceArgs = rpcTracing === void 0 ? [] : yield* RpcTracing.withRpcTraceContext([]);
+			const raw = yield* callThreadObject(threadId, (stub) => stub[hostRpcMethods[operation]](encoded, ...traceArgs), (cause) => ThreadClientError.make({
+				threadId,
+				message: boundHostDiagnostic(`${operation} did not reach the Thread Object: ${safeCauseMessage(cause, "the RPC failed without a diagnostic")}`),
+				cause,
+				...cloudflareFailureSignals(cause)
+			})).pipe(Effect.provideService(ThreadObjectNamespace, namespace));
+			return yield* decodeHostResponse(raw).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`The ${operation} answer could not be decoded: ${error.message}`) })));
+		}, (effect, threadId, operation) => rpcTracing === void 0 ? Effect.withSpan(effect, "CloudflareThreadClient.call", { attributes: {
+			threadId,
+			operation
+		} }) : RpcTracing.withRpcClientSpan(effect, rpcTracing, hostRpcMethods[operation]));
+		const expect = (threadId, operation, resultSchema, failureSchema) => {
+			const isExpectedResult = Schema.is(resultSchema);
+			const isExpectedFailure = Schema.is(failureSchema);
+			return (response) => {
+				if (response._tag === "HostFailed") {
+					const failure = response.failure;
+					return isExpectedFailure(failure) ? Effect.fail(failure) : Effect.fail(outOfContract(threadId, operation, `failure ${failure._tag}`));
+				}
+				if (!isExpectedResult(response)) return Effect.fail(outOfContract(threadId, operation, `result ${response._tag}`));
+				return Effect.succeed(response);
+			};
+		};
+		const readPage = (threadId, options) => Effect.gen(function* () {
+			const request = ObservePageRequest.make({
+				...options?.afterSequence === void 0 ? {} : { afterSequence: options.afterSequence },
+				limit: options?.limit ?? 256
+			});
+			const encoded = yield* encodeObservePageRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`observePage request encode failed: ${error.message}`) })));
+			const response = yield* call(threadId, "observePage", encoded);
+			return (yield* expect(threadId, "observePage", ObservedPage, ClientObserveHostFailure)(response)).records;
+		});
+		const cancelProgress = (threadId, waiterId) => encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(Effect.mapError(() => void 0), Effect.flatMap((encoded) => call(threadId, "cancelProgress", encoded)), Effect.interruptible, Effect.timeout(PROGRESS_CANCELLATION_TIMEOUT), Effect.asVoid, Effect.ignore);
+		return CloudflareThreadClient.of({
+			submit: (agent, input, options) => Effect.gen(function* () {
+				const encodedInput = yield* Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError((cause) => AgentInputError.make({ message: `Unable to encode Agent input: ${cause.message}` })));
+				const inputPayload = yield* Schema.decodeUnknownEffect(PersistedJson)(encodedInput).pipe(Effect.mapError(() => AgentInputError.make({ message: "Agent input does not satisfy the canonical persistence bounds" })));
+				const request = SubmitRequest.make({
+					agentId: agent.definition.id,
+					principal: options.principal,
+					idempotencyKey: options.idempotencyKey,
+					...options.admissionGroup === void 0 ? {} : { admissionGroup: options.admissionGroup },
+					...options.admissionFence === void 0 ? {} : { admissionFence: options.admissionFence },
+					...options.workerAdmission === void 0 ? {} : { workerAdmission: options.workerAdmission },
+					...options.messageAdmission === void 0 ? {} : { messageAdmission: options.messageAdmission },
+					definitions: options.definitions,
+					inputPayload
+				});
+				const encoded = yield* encodeSubmitRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`submit request encode failed: ${error.message}`) })));
+				const response = yield* call(options.threadId, "submit", encoded);
+				return (yield* expect(options.threadId, "submit", SubmitSucceeded, ClientSubmitHostFailure)(response)).receipt;
+			}),
+			submissionStatus: (receipt) => Effect.gen(function* () {
+				const encoded = yield* encodeReceipt(receipt).pipe(Effect.mapError(() => HostProtocolError.make({ message: "Invalid receipt" })));
+				const response = yield* call(receipt.threadId, "submissionStatus", encoded);
+				return (yield* expect(receipt.threadId, "submissionStatus", SubmissionStatusResponse, ClientAwaitHostFailure)(response)).status;
+			}),
+			awaitSettlement: (receipt) => Effect.gen(function* () {
+				const encoded = yield* encodeReceipt(receipt).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`receipt encode failed: ${error.message}`) })));
+				const response = yield* call(receipt.threadId, "awaitSettlement", encoded);
+				return (yield* expect(receipt.threadId, "awaitSettlement", SettlementReached, ClientAwaitHostFailure)(response)).settlement;
+			}),
+			awaitSettlementRecord: (receipt) => Effect.gen(function* () {
+				const encoded = yield* encodeReceipt(receipt).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`receipt encode failed: ${error.message}`) })));
+				const response = yield* call(receipt.threadId, "awaitSettlementRecord", encoded);
+				return (yield* expect(receipt.threadId, "awaitSettlementRecord", SettlementRecordReached, ClientAwaitHostFailure)(response)).record;
+			}),
+			awaitProgress: (threadId, afterSequence) => Effect.gen(function* () {
+				const waiterId = yield* crypto.randomUUIDv4().pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress cancellation identity generation failed: ${error.message}`) })));
+				const request = AwaitProgressRequest.make({
+					afterSequence,
+					waiterId
+				});
+				const encoded = yield* encodeAwaitProgressRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress request encode failed: ${error.message}`) })));
+				const attempt = (retry) => call(threadId, "awaitProgress", encoded).pipe(Effect.flatMap(expect(threadId, "awaitProgress", ProgressObserved, ClientObserveHostFailure)), Effect.asVoid, 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))) : Effect.fail(error)));
+				yield* attempt(0).pipe(Effect.onInterrupt(() => cancelProgress(threadId, waiterId)));
+			}),
+			watchText: (threadId) => Stream.unwrap(Effect.gen(function* () {
+				const traceArgs = rpcTracing === void 0 ? [] : yield* RpcTracing.withRpcTraceContext([]);
+				const openingFailure = (cause) => ThreadClientError.make({
+					threadId,
+					message: "Provisional text observation could not reach the Thread Object",
+					cause,
+					...cloudflareFailureSignals(cause)
+				});
+				const target = yield* RpcTargets.get(namespace, threadId, () => namespace.get(threadId)).pipe(Effect.mapError(openingFailure));
+				let request;
+				let received;
+				let closed = false;
+				const cancel = () => {
+					const value = received;
+					received = void 0;
+					return value instanceof ReadableStream && !value.locked ? value.cancel().catch(() => void 0) : Promise.resolve();
+				};
+				yield* Effect.addFinalizer(() => Effect.try({
+					try: () => {
+						closed = true;
+						if (Predicate.hasProperty(request, Symbol.dispose)) {
+							const dispose = request[Symbol.dispose];
+							if (typeof dispose === "function") dispose.call(request);
+						}
+					},
+					catch: () => void 0
+				}).pipe(Effect.ignore, Effect.andThen(Effect.tryPromise({
+					try: cancel,
+					catch: () => void 0
+				}).pipe(Effect.interruptible, Effect.timeout(PROGRESS_CANCELLATION_TIMEOUT), Effect.ignore))));
+				const raw = yield* Effect.tryPromise({
+					try: () => {
+						request = target.watchTextEncoded(Schema.encodeSync(Request)({ schemaVersion: 1 }), ...traceArgs);
+						return request.then((value) => {
+							received = value;
+							return closed ? cancel().then(() => value) : value;
+						});
+					},
+					catch: openingFailure
+				}).pipe(Effect.interruptible, Effect.tapCause(() => RpcTargets.invalidate(target)));
+				if (raw instanceof ReadableStream) return decodeLiveText(threadId, raw);
+				const response = yield* decodeHostResponse(raw).pipe(Effect.mapError(liveTextProtocolFailure));
+				if (response._tag === "HostFailed" && Schema.is(ClientObserveHostFailure)(response.failure)) return yield* response.failure;
+				return yield* liveTextProtocolFailure();
+			})),
+			readPage,
+			readAll: (threadId) => Effect.gen(function* () {
+				const all = [];
+				let after;
+				for (;;) {
+					const page = yield* readPage(threadId, {
+						afterSequence: after,
+						limit: 1024
+					});
+					all.push(...page);
+					const last = page.at(-1);
+					if (page.length < 1024 || last === void 0) return all;
+					after = last.sequence;
+				}
+			}),
+			abort: (threadId, command) => Effect.gen(function* () {
+				const encoded = yield* encodeAbortCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`abort command encode failed: ${error.message}`) })));
+				const response = yield* call(threadId, "abort", encoded);
+				return (yield* expect(threadId, "abort", AbortRecorded, ClientAbortHostFailure)(response)).intent;
+			}),
+			resolveApproval: (threadId, command) => Effect.gen(function* () {
+				const encoded = yield* encodeApprovalDecisionCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`approval command encode failed: ${error.message}`) })));
+				const response = yield* call(threadId, "resolveApproval", encoded);
+				return (yield* expect(threadId, "resolveApproval", ApprovalRecorded, ClientApprovalHostFailure)(response)).intent;
+			}),
+			resolveUnknown: (threadId, command) => Effect.gen(function* () {
+				const encoded = yield* encodeUnknownResolutionCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`resolution command encode failed: ${error.message}`) })));
+				const response = yield* call(threadId, "resolveUnknown", encoded);
+				return (yield* expect(threadId, "resolveUnknown", UnknownResolutionRecorded, ClientUnknownHostFailure)(response)).intent;
+			})
+		});
+	}));
+};
+//#endregion
+export { decodeSubmitRequest as A, encodeUnknownResolutionCommand as B, decodeAbortCommand as C, decodeHostResponse as D, decodeCancelProgressRequest as E, encodeCancelProgressRequest as F, Request as G, MAX_DELTA_LENGTH as H, encodeHostResponse as I, isBoundedEvent as K, encodeObservePageRequest as L, encodeAbortCommand as M, encodeApprovalDecisionCommand as N, decodeObservePageRequest as O, encodeAwaitProgressRequest as P, encodeReceipt as R, boundHostDiagnostic as S, decodeAwaitProgressRequest as T, MAX_DRAFT_LENGTH as U, Frame as V, MAX_FRAME_BYTES as W, SubmissionStatusResponse as _, CloudflareThreadClient as a, ThreadClientError as b, HostFailure as c, ObservePageRequest as d, ObservedPage as f, SettlementRecordReached as g, SettlementReached as h, CancelProgressRequest as i, decodeUnknownResolutionCommand as j, decodeReceipt as k, HostProtocolError as l, ProgressObserved as m, ApprovalRecorded as n, CloudflareThreadClient_exports as o, ProgressCancelled as p, cloudflareCryptoLayer as q, AwaitProgressRequest as r, HostFailed as s, AbortRecorded as t, HostResponse as u, SubmitRequest as v, decodeApprovalDecisionCommand as w, UnknownResolutionRecorded as x, SubmitSucceeded as y, encodeSubmitRequest as z };
+
+//# sourceMappingURL=CloudflareThreadClient-CZm0TvUe.mjs.map