@runtypelabs/cloudflare-agents 0.1.1

package/dist/durable-object.mjs

@@ -0,0 +1,891 @@
+import { n as operationSpanId, t as createRunIdentity } from "./chunk-BuRpWjxB.mjs";
+import { DurableObject } from "cloudflare:workers";
+//#region package.json
+var version = "0.1.1";
+//#endregion
+//#region src/otlp.ts
+function otlpValue(value) {
+	if (typeof value === "string") return { stringValue: value };
+	if (typeof value === "boolean") return { boolValue: value };
+	return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+}
+function attributes(values) {
+	return Object.entries(values).map(([key, value]) => ({
+		key,
+		value: otlpValue(value)
+	}));
+}
+/** Encodes one immutable Cloudflare Agents submission trace as OTLP/JSON. */
+function encodeTraceBatch(spans, identity) {
+	return JSON.stringify({ resourceSpans: [{
+		resource: { attributes: attributes({
+			"runtype.agent.id": identity.agentId,
+			"runtype.adapter.name": "cloudflare-agents",
+			"runtype.adapter.version": identity.adapterVersion
+		}) },
+		scopeSpans: [{
+			scope: {
+				name: "runtype.cloudflare-agents",
+				version: identity.adapterVersion
+			},
+			spans: spans.map((span) => ({
+				traceId: span.traceId,
+				spanId: span.spanId,
+				...span.parentSpanId ? { parentSpanId: span.parentSpanId } : {},
+				name: span.name,
+				startTimeUnixNano: span.startTimeUnixNano,
+				endTimeUnixNano: span.endTimeUnixNano,
+				attributes: attributes(span.attributes),
+				...span.status ? { status: {
+					code: span.status.code,
+					...span.status.message ? { message: span.status.message } : {}
+				} } : {}
+			}))
+		}]
+	}] });
+}
+//#endregion
+//#region src/sender.ts
+/** Builds the one outbound OTLP request without exposing delivery state. */
+function createOtlpDeliveryRequest(options) {
+	return new Request(`${options.baseUrl}/v1/otel/v1/traces`, {
+		method: "POST",
+		redirect: "manual",
+		signal: options.signal,
+		headers: {
+			authorization: `Bearer ${options.apiKey}`,
+			"content-type": "application/json",
+			"x-runtype-agent-id": options.agentId
+		},
+		body: options.body.slice().buffer
+	});
+}
+//#endregion
+//#region src/session.ts
+const MAX_MODEL_STEPS = 128;
+const MAX_TOOL_CALLS = 256;
+function nanos(timestamp) {
+	return (BigInt(Math.trunc(timestamp)) * 1000000n).toString();
+}
+function contentAttribute(value) {
+	return value === void 0 ? void 0 : JSON.stringify(value);
+}
+function inputAttributes(input) {
+	if (!input) return {};
+	const system = contentAttribute(input.system);
+	const combined = [...typeof input.system === "string" ? [{
+		role: "system",
+		content: input.system
+	}] : Array.isArray(input.system) ? input.system : [], ...Array.isArray(input.messages) ? input.messages : []];
+	const messages = combined.length > 0 ? JSON.stringify(combined) : contentAttribute(input.messages);
+	return {
+		...system === void 0 ? {} : { "gen_ai.system_instructions": system },
+		...messages === void 0 ? {} : { "gen_ai.input.messages": messages }
+	};
+}
+function errorMessage(value) {
+	if (typeof value === "string") return value;
+	if (value && !Array.isArray(value) && typeof value === "object" && typeof value.message === "string") return value.message;
+}
+function outputAttributes(output) {
+	if (output === void 0) return {};
+	return { "gen_ai.output.messages": JSON.stringify([{
+		role: "assistant",
+		content: output
+	}]) };
+}
+async function span(session, operationId, name, startedAt, endedAt, attributes) {
+	return {
+		traceId: session.identity.traceId,
+		spanId: await operationSpanId(session.identity.traceId, operationId),
+		parentSpanId: session.identity.rootSpanId,
+		name,
+		startTimeUnixNano: nanos(startedAt),
+		endTimeUnixNano: nanos(Math.max(startedAt, endedAt)),
+		attributes: {
+			"gen_ai.conversation.id": session.identity.conversationId,
+			...attributes
+		}
+	};
+}
+/** Creates the immutable start marker and state for one accepted submission. */
+async function beginSession(identity, exchangeId, now) {
+	if (!Number.isSafeInteger(now) || now <= 0) throw new Error("Invalid adapter timestamp");
+	const session = {
+		version: 1,
+		identity,
+		exchangeId,
+		startedAt: now,
+		models: [],
+		tools: []
+	};
+	return {
+		session,
+		spans: [await span(session, "accepted", "runtype.adapter.accepted", now, now, { "runtype.execution.id": identity.traceId })]
+	};
+}
+/** Reduce sanitized observations; persist returned state and spans in one transaction. */
+async function reduceObservation(previous, observation, now) {
+	if (!Number.isSafeInteger(now) || now <= 0) throw new Error("Invalid adapter timestamp");
+	const session = structuredClone(previous);
+	const unchanged = () => ({
+		session,
+		spans: []
+	});
+	const missing = () => {
+		session.telemetryIncomplete = true;
+		return {
+			...unchanged(),
+			diagnostic: "missing_operation_start"
+		};
+	};
+	if (observation.turn.submissionId !== session.identity.submissionId || observation.turn.conversationId !== session.identity.conversationId || observation.turn.exchangeId !== session.exchangeId) return {
+		...unchanged(),
+		diagnostic: "identity_conflict"
+	};
+	if (session.terminal) return unchanged();
+	if (observation.kind === "incomplete") {
+		session.telemetryIncomplete = true;
+		session.terminal = "incomplete";
+		return {
+			...unchanged(),
+			diagnostic: "incomplete"
+		};
+	}
+	if (observation.kind === "unsupported" || observation.turn.continuation) {
+		session.terminal = "unsupported";
+		return {
+			...unchanged(),
+			diagnostic: "unsupported"
+		};
+	}
+	if (observation.kind === "accepted") return unchanged();
+	if (observation.kind === "model_input") {
+		if (observation.stepNumber === void 0) return unchanged();
+		if (session.models.some((model) => model.index === observation.stepNumber)) return unchanged();
+		if (session.models.length >= MAX_MODEL_STEPS) return {
+			...unchanged(),
+			diagnostic: "session_limit"
+		};
+		session.models.push({
+			index: observation.stepNumber,
+			startedAt: now,
+			input: observation
+		});
+		return unchanged();
+	}
+	if (observation.kind === "model_step") {
+		const model = session.models.find((item) => item.index === observation.stepNumber);
+		if (!model) return missing();
+		if (model.result) return unchanged();
+		model.result = observation;
+		return {
+			session,
+			spans: [await span(session, `chat:${model.index}`, `chat ${observation.model.modelId}`, model.startedAt, now, {
+				"gen_ai.operation.name": "chat",
+				"gen_ai.request.model": observation.model.modelId,
+				"gen_ai.provider.name": observation.model.provider,
+				...observation.usage.inputTokens === void 0 ? {} : { "gen_ai.usage.input_tokens": observation.usage.inputTokens },
+				...observation.usage.outputTokens === void 0 ? {} : { "gen_ai.usage.output_tokens": observation.usage.outputTokens },
+				"runtype.iteration": model.index,
+				...inputAttributes(model.input),
+				...outputAttributes(observation.output)
+			})]
+		};
+	}
+	if (observation.kind === "tool_started") {
+		const id = observation.toolCall.toolCallId;
+		if (!id) return missing();
+		if (session.tools.some((tool) => tool.id === id)) return unchanged();
+		if (session.tools.length >= MAX_TOOL_CALLS) return {
+			...unchanged(),
+			diagnostic: "session_limit"
+		};
+		session.tools.push({
+			id,
+			startedAt: now,
+			input: observation,
+			ended: false
+		});
+		return unchanged();
+	}
+	if (observation.kind === "tool_finished") {
+		const tool = session.tools.find((item) => item.id === observation.toolCall.toolCallId);
+		if (!tool) return missing();
+		if (tool.ended) return unchanged();
+		tool.ended = true;
+		const name = tool.input.toolCall.toolName ?? "unknown";
+		const parameters = contentAttribute(tool.input.toolCall.input);
+		const result = contentAttribute(observation.output);
+		const durationMs = Math.max(0, Math.trunc(observation.durationMs));
+		const ended = await span(session, `tool:${tool.id}`, `execute_tool ${name}`, Math.max(1, now - durationMs), now, {
+			"gen_ai.operation.name": "execute_tool",
+			"gen_ai.tool.call.id": tool.id,
+			"gen_ai.tool.name": name,
+			...parameters === void 0 ? {} : { "gen_ai.tool.call.arguments": parameters },
+			...result === void 0 ? {} : { "gen_ai.tool.call.result": result }
+		});
+		const message = errorMessage(observation.error);
+		ended.status = {
+			code: observation.success ? 1 : 2,
+			...message === void 0 ? {} : { message }
+		};
+		return {
+			session,
+			spans: [ended]
+		};
+	}
+	if (observation.kind === "finished" && (session.models.some((model) => !model.result) || session.tools.some((tool) => !tool.ended))) {
+		session.telemetryIncomplete = true;
+		session.terminal = "incomplete";
+		return {
+			...unchanged(),
+			diagnostic: "incomplete"
+		};
+	}
+	if (session.telemetryIncomplete) {
+		session.terminal = "unsupported";
+		return {
+			...unchanged(),
+			diagnostic: "unsupported"
+		};
+	}
+	session.terminal = observation.kind;
+	const steps = session.models.filter((model) => model.result).sort((a, b) => a.index - b.index);
+	const root = await span(session, "root", "invoke_agent", session.startedAt, now, {
+		"gen_ai.operation.name": "invoke_agent",
+		"runtype.execution.id": session.identity.traceId,
+		"runtype.stop_reason": observation.kind === "finished" ? "stop" : observation.kind === "aborted" ? "cancelled" : "error",
+		...steps.length > 0 && steps.every((model) => model.result?.usage.inputTokens !== void 0) ? { "gen_ai.usage.input_tokens": steps.reduce((sum, model) => sum + model.result.usage.inputTokens, 0) } : {},
+		...steps.length > 0 && steps.every((model) => model.result?.usage.outputTokens !== void 0) ? { "gen_ai.usage.output_tokens": steps.reduce((sum, model) => sum + model.result.usage.outputTokens, 0) } : {},
+		...inputAttributes(steps[0]?.input),
+		...outputAttributes(steps.at(-1)?.result?.output)
+	});
+	delete root.parentSpanId;
+	const message = "error" in observation ? errorMessage(observation.error) : void 0;
+	root.status = {
+		code: observation.kind === "finished" ? 1 : 2,
+		...message === void 0 ? {} : { message }
+	};
+	return {
+		session,
+		spans: [root]
+	};
+}
+//#endregion
+//#region src/outbox.ts
+const OUTBOX_RETENTION_MS = 6048e5;
+const OUTBOX_LEASE_MS = 6e4;
+const outboxStatsKey = "outbox:stats";
+const knownFailureCodes = /* @__PURE__ */ new Set([
+	"network_error",
+	"network_abort_error",
+	"network_type_error",
+	"network_unknown_error",
+	"partial_success",
+	"invalid_success_response",
+	"success_response_too_large"
+]);
+function emptyStats() {
+	return {
+		expired: 0,
+		rejected: 0,
+		failureCounts: {}
+	};
+}
+function safeFailureCode(code) {
+	return /^http_[0-9]{3}$/.test(code) || knownFailureCodes.has(code) ? code : "other";
+}
+const MAX_RESPONSE_BYTES = 16384;
+const pendingKey = (id) => `outbox:pending:${id}`;
+const completedKey = (id) => `outbox:completed:${id}`;
+const hashBytes = async (body) => {
+	const copy = body.slice().buffer;
+	const digest = await crypto.subtle.digest("SHA-256", copy);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+function validBatch(batch) {
+	return batch.version === 1 && batch.deliveryId.length > 0 && Number.isSafeInteger(batch.createdAt) && batch.createdAt > 0;
+}
+function retryAt(now, attempts) {
+	return now + Math.min(3e5, 1e4 * 2 ** Math.min(9, Math.max(0, attempts - 1)));
+}
+async function incrementStat(transaction, key) {
+	const stats = {
+		...emptyStats(),
+		...await transaction.get(outboxStatsKey)
+	};
+	stats[key] += 1;
+	await transaction.put(outboxStatsKey, stats);
+}
+async function recordFailure(transaction, code) {
+	const stats = {
+		...emptyStats(),
+		...await transaction.get(outboxStatsKey)
+	};
+	const safe = safeFailureCode(code);
+	stats.failureCounts[safe] = (stats.failureCounts[safe] ?? 0) + 1;
+	await transaction.put(outboxStatsKey, stats);
+}
+async function queueTotals(transaction, now) {
+	const entries = await transaction.list("outbox:pending:");
+	let rows = 0;
+	let bytes = 0;
+	for (const { key, value } of entries) {
+		if (value.expiresAt <= now) {
+			await transaction.delete(key);
+			await incrementStat(transaction, "expired");
+			continue;
+		}
+		rows += 1;
+		bytes += value.body.byteLength;
+	}
+	return {
+		rows,
+		bytes
+	};
+}
+async function pruneCompleted(transaction, now) {
+	for (const { key, value } of await transaction.list("outbox:completed:")) if (value.expiresAt <= now) await transaction.delete(key);
+}
+/** Transactional immutable OTLP queue. The caller may combine this with session state in one transaction. */
+var DurableOtlpOutbox = class {
+	storage;
+	constructor(storage) {
+		this.storage = storage;
+	}
+	async enqueue(batch, now) {
+		return this.storage.transaction((transaction) => this.enqueueTransaction(transaction, batch, now));
+	}
+	async enqueueTransaction(transaction, batch, now) {
+		const totals = await queueTotals(transaction, now);
+		await pruneCompleted(transaction, now);
+		const completedRows = (await transaction.list("outbox:completed:")).length;
+		if (!validBatch(batch)) return {
+			accepted: false,
+			code: "invalid_payload",
+			queuedRows: totals.rows,
+			queuedBytes: totals.bytes
+		};
+		if (batch.body.byteLength > 262144) return {
+			accepted: false,
+			code: "payload_too_large",
+			queuedRows: totals.rows,
+			queuedBytes: totals.bytes
+		};
+		const bodyHash = await hashBytes(batch.body);
+		const completed = await transaction.get(completedKey(batch.deliveryId));
+		if (completed && completed.expiresAt > now) {
+			if (completed.bodyHash !== bodyHash) return {
+				accepted: false,
+				code: "invalid_payload",
+				queuedRows: totals.rows,
+				queuedBytes: totals.bytes
+			};
+			return {
+				accepted: true,
+				duplicate: true,
+				queuedAt: now
+			};
+		}
+		if (completed) await transaction.delete(completedKey(batch.deliveryId));
+		const existing = await transaction.get(pendingKey(batch.deliveryId));
+		if (existing) {
+			if (existing.bodyHash !== bodyHash) return {
+				accepted: false,
+				code: "invalid_payload",
+				queuedRows: totals.rows,
+				queuedBytes: totals.bytes
+			};
+			return {
+				accepted: true,
+				duplicate: true,
+				queuedAt: existing.createdAt
+			};
+		}
+		if (totals.rows + completedRows >= 1e3 || totals.bytes + batch.body.byteLength > 16777216) return {
+			accepted: false,
+			code: "outbox_full",
+			queuedRows: totals.rows,
+			queuedBytes: totals.bytes
+		};
+		await transaction.put(pendingKey(batch.deliveryId), {
+			version: 1,
+			deliveryId: batch.deliveryId,
+			body: batch.body,
+			bodyHash,
+			createdAt: batch.createdAt,
+			expiresAt: now + OUTBOX_RETENTION_MS,
+			attempts: 0,
+			nextAttemptAt: now
+		});
+		return {
+			accepted: true,
+			duplicate: false,
+			queuedAt: now
+		};
+	}
+	async claim(now, limit = 16) {
+		return this.storage.transaction((transaction) => this.claimTransaction(transaction, now, limit));
+	}
+	async claimTransaction(transaction, now, limit = 16) {
+		const entries = await transaction.list("outbox:pending:");
+		const claimed = [];
+		for (const { key, value } of entries.sort((a, b) => a.value.nextAttemptAt - b.value.nextAttemptAt)) {
+			if (claimed.length === limit) break;
+			if (value.expiresAt <= now) {
+				await transaction.delete(key);
+				await incrementStat(transaction, "expired");
+				continue;
+			}
+			if (value.nextAttemptAt > now || (value.leaseUntil ?? 0) > now) continue;
+			const leaseToken = crypto.randomUUID();
+			value.leaseToken = leaseToken;
+			value.leaseUntil = now + OUTBOX_LEASE_MS;
+			value.attempts += 1;
+			await transaction.put(key, value);
+			claimed.push({
+				version: 1,
+				deliveryId: value.deliveryId,
+				body: value.body,
+				createdAt: value.createdAt,
+				leaseToken,
+				attempts: value.attempts
+			});
+		}
+		return claimed;
+	}
+	async settle(delivery, result, now) {
+		await this.storage.transaction((transaction) => this.settleTransaction(transaction, delivery, result, now));
+	}
+	async settleTransaction(transaction, delivery, result, now) {
+		const key = pendingKey(delivery.deliveryId);
+		const entry = await transaction.get(key);
+		if (!entry || entry.leaseToken !== delivery.leaseToken) return;
+		if (result.kind === "success") {
+			await transaction.delete(key);
+			await transaction.put(completedKey(entry.deliveryId), {
+				version: 1,
+				bodyHash: entry.bodyHash,
+				expiresAt: now + OUTBOX_RETENTION_MS
+			});
+			return;
+		}
+		if (result.kind === "reject" || entry.expiresAt <= now) {
+			await transaction.delete(key);
+			await incrementStat(transaction, result.kind === "reject" ? "rejected" : "expired");
+			if (result.kind === "reject") await recordFailure(transaction, result.code);
+			return;
+		}
+		entry.leaseToken = void 0;
+		entry.leaseUntil = void 0;
+		entry.lastErrorCode = safeFailureCode(result.code);
+		await recordFailure(transaction, result.code);
+		entry.nextAttemptAt = retryAt(now, entry.attempts);
+		await transaction.put(key, entry);
+	}
+	async stats() {
+		return this.storage.transaction(async (transaction) => ({
+			...emptyStats(),
+			...await transaction.get(outboxStatsKey)
+		}));
+	}
+	async health(now) {
+		return this.storage.transaction(async (transaction) => {
+			let pendingRows = 0;
+			let pendingBytes = 0;
+			let earliestRetryAt;
+			const failureCounts = {};
+			for (const { key, value } of await transaction.list("outbox:pending:")) {
+				if (value.expiresAt <= now) {
+					await transaction.delete(key);
+					await incrementStat(transaction, "expired");
+					continue;
+				}
+				pendingRows += 1;
+				pendingBytes += value.body.byteLength;
+				const due = Math.max(value.nextAttemptAt, value.leaseUntil ?? 0);
+				earliestRetryAt = earliestRetryAt === void 0 ? due : Math.min(earliestRetryAt, due);
+				if (value.lastErrorCode) failureCounts[value.lastErrorCode] = (failureCounts[value.lastErrorCode] ?? 0) + 1;
+			}
+			return {
+				pendingRows,
+				pendingBytes,
+				...earliestRetryAt === void 0 ? {} : { earliestRetryAt },
+				failureCounts
+			};
+		});
+	}
+	async nextDue(now) {
+		return this.storage.transaction((transaction) => this.nextDueTransaction(transaction, now));
+	}
+	async nextDueTransaction(transaction, now) {
+		const entries = await transaction.list("outbox:pending:");
+		let earliest;
+		for (const { key, value } of entries) {
+			if (value.expiresAt <= now) {
+				await transaction.delete(key);
+				await incrementStat(transaction, "expired");
+				continue;
+			}
+			const due = Math.max(value.nextAttemptAt, value.leaseUntil ?? 0);
+			earliest = earliest === void 0 ? due : Math.min(earliest, due);
+		}
+		for (const { key, value } of await transaction.list("outbox:completed:")) if (value.expiresAt <= now) await transaction.delete(key);
+		else earliest = earliest === void 0 ? value.expiresAt : Math.min(earliest, value.expiresAt);
+		return earliest;
+	}
+};
+async function boundedResponseText(response) {
+	const declared = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declared) && declared > MAX_RESPONSE_BYTES) return void 0;
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	while (true) {
+		const next = await reader.read();
+		if (next.done) break;
+		bytes += next.value.byteLength;
+		if (bytes > MAX_RESPONSE_BYTES) {
+			await reader.cancel();
+			return;
+		}
+		chunks.push(next.value);
+	}
+	const joined = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		joined.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(joined);
+}
+async function classifyDeliveryResponse(response) {
+	if (response.status !== 200) {
+		if (response.status >= 300 && response.status < 400 || response.status === 401 || response.status === 403 || response.status === 408 || response.status === 429 || response.status >= 500) return {
+			kind: "retry",
+			code: `http_${response.status}`
+		};
+		return {
+			kind: "reject",
+			code: `http_${response.status}`
+		};
+	}
+	const body = await boundedResponseText(response);
+	if (body === void 0) return {
+		kind: "retry",
+		code: "success_response_too_large"
+	};
+	if (body.length === 0) return { kind: "success" };
+	try {
+		const parsed = JSON.parse(body);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {
+			kind: "retry",
+			code: "invalid_success_response"
+		};
+		const keys = Object.keys(parsed);
+		if (keys.length === 0) return { kind: "success" };
+		if (keys.length !== 1 || !("partialSuccess" in parsed)) return {
+			kind: "retry",
+			code: "invalid_success_response"
+		};
+		const partial = parsed.partialSuccess;
+		if (typeof partial !== "object" || partial === null || Array.isArray(partial)) return {
+			kind: "retry",
+			code: "invalid_success_response"
+		};
+		const entries = Object.entries(partial);
+		if (entries.every(([key, value]) => key.startsWith("rejected") && typeof value === "number" && value === 0)) return { kind: "success" };
+		return entries.some(([key, value]) => key.startsWith("rejected") && typeof value === "number" && value > 0) || entries.length > 0 ? {
+			kind: "retry",
+			code: "partial_success"
+		} : { kind: "success" };
+	} catch {
+		return {
+			kind: "retry",
+			code: "invalid_success_response"
+		};
+	}
+}
+//#endregion
+//#region src/durable-object.ts
+const SESSION_RETENTION_MS = OUTBOX_RETENTION_MS;
+const SESSION_MAX_BYTES = 65536;
+const SESSION_MAX_ROWS = 1e3;
+const SESSION_MAX_BYTES_TOTAL = 16777216;
+const diagnosticsKey = "adapter:diagnostics";
+const sessionKey = (traceId) => `adapter:session:${traceId}`;
+var CloudflareOutboxStorage = class {
+	storage;
+	constructor(storage) {
+		this.storage = storage;
+	}
+	transaction(callback) {
+		return this.storage.transaction(async (storage) => callback(this.transactionView(storage)));
+	}
+	transactionView(storage) {
+		return {
+			get: (key) => storage.get(key),
+			put: async (key, value) => {
+				await storage.put(key, value);
+			},
+			delete: async (key) => {
+				await storage.delete(key);
+			},
+			list: async (prefix) => Array.from((await storage.list({ prefix })).entries()).map(([key, value]) => ({
+				key,
+				value
+			}))
+		};
+	}
+};
+/** A companion DO; it never reads or modifies an application Agent's alarm. */
+var RuntypeOtlpOutbox = class extends DurableObject {
+	outbox;
+	storage;
+	constructor(ctx, env) {
+		super(ctx, env);
+		this.storage = new CloudflareOutboxStorage(ctx.storage);
+		this.outbox = new DurableOtlpOutbox(this.storage);
+	}
+	async observe(observation) {
+		const identity = await createRunIdentity({
+			agentId: this.env.RUNTYPE_AGENT_ID,
+			submissionId: observation.turn.submissionId,
+			conversationId: observation.turn.conversationId
+		});
+		const now = Date.now();
+		return this.ctx.storage.transaction(async (transaction) => {
+			const view = this.storage.transactionView(transaction);
+			const key = sessionKey(identity.traceId);
+			const stored = await view.get(key);
+			if (stored?.expiresAt !== void 0 && stored.expiresAt <= now) {
+				await this.recordDiagnostic(view, "missingSession");
+				return {
+					accepted: false,
+					duplicate: false,
+					diagnostic: "missing_session"
+				};
+			}
+			const live = stored;
+			if (!live && observation.kind !== "accepted") {
+				await this.recordDiagnostic(view, "missingSession");
+				return {
+					accepted: false,
+					duplicate: false,
+					diagnostic: "missing_session"
+				};
+			}
+			const reduction = live ? await reduceObservation(live.session, observation, now) : await beginSession(identity, observation.turn.exchangeId, now);
+			if (reduction.diagnostic === "identity_conflict" || reduction.diagnostic === "session_limit" || reduction.diagnostic === "missing_operation_start") {
+				if (live && reduction.diagnostic !== "identity_conflict") await this.markIncomplete(view, key, live);
+				await this.recordDiagnostic(view, this.diagnosticKey(reduction.diagnostic));
+				return {
+					accepted: false,
+					duplicate: false,
+					diagnostic: reduction.diagnostic
+				};
+			}
+			const expiresAt = live?.expiresAt ?? reduction.session.startedAt + SESSION_RETENTION_MS;
+			if (!await this.admitSession(view, key, reduction.session, expiresAt, now)) {
+				if (live) await this.markIncomplete(view, key, live);
+				await this.recordDiagnostic(view, "sessionLimit");
+				return {
+					accepted: false,
+					duplicate: false,
+					diagnostic: "session_limit"
+				};
+			}
+			const batch = reduction.spans.length === 0 ? void 0 : await this.batch(identity.traceId, reduction.spans, now);
+			if (batch) {
+				const receipt = await this.outbox.enqueueTransaction(view, batch, now);
+				if (!receipt.accepted) {
+					if (live) await this.markIncomplete(view, key, live);
+					await this.recordDiagnostic(view, "outboxRefused");
+					return {
+						accepted: false,
+						duplicate: false,
+						diagnostic: receipt.code,
+						queuedRows: receipt.queuedRows,
+						queuedBytes: receipt.queuedBytes
+					};
+				}
+				if (receipt.duplicate) await this.recordDiagnostic(view, "duplicate");
+			}
+			await view.put(key, {
+				version: 1,
+				expiresAt,
+				session: reduction.session
+			});
+			if (reduction.diagnostic) await this.recordDiagnostic(view, this.diagnosticKey(reduction.diagnostic));
+			else await this.recordDiagnostic(view, "accepted");
+			await this.armTransaction(transaction, view, now);
+			return {
+				accepted: true,
+				duplicate: batch === void 0,
+				...reduction.diagnostic === void 0 ? {} : { diagnostic: reduction.diagnostic }
+			};
+		});
+	}
+	async diagnostics() {
+		const diagnostics = await this.ctx.storage.get(diagnosticsKey) ?? {
+			accepted: 0,
+			duplicate: 0,
+			missingSession: 0,
+			identityConflict: 0,
+			sessionLimit: 0,
+			missingOperationStart: 0,
+			incomplete: 0,
+			unsupported: 0,
+			outboxRefused: 0,
+			expired: 0,
+			rejected: 0,
+			pendingRows: 0,
+			pendingBytes: 0,
+			failureCounts: {}
+		};
+		const outbox = await this.outbox.stats();
+		const health = await this.outbox.health(Date.now());
+		return {
+			...diagnostics,
+			expired: outbox.expired,
+			rejected: outbox.rejected,
+			pendingRows: health.pendingRows,
+			pendingBytes: health.pendingBytes,
+			...health.earliestRetryAt === void 0 ? {} : { earliestRetryAt: health.earliestRetryAt },
+			failureCounts: outbox.failureCounts
+		};
+	}
+	async enqueue(batch) {
+		const now = Date.now();
+		return this.ctx.storage.transaction(async (transaction) => {
+			const view = this.storage.transactionView(transaction);
+			const receipt = await this.outbox.enqueueTransaction(view, batch, now);
+			if (receipt.accepted) await this.armTransaction(transaction, view, now);
+			return receipt;
+		});
+	}
+	async alarm() {
+		const now = Date.now();
+		const claimed = await this.ctx.storage.transaction(async (transaction) => {
+			await transaction.setAlarm(now + 1e3);
+			return this.outbox.claimTransaction(this.storage.transactionView(transaction), now, 1);
+		});
+		for (const delivery of claimed) await this.send(delivery);
+		await this.ctx.storage.transaction(async (transaction) => {
+			const view = this.storage.transactionView(transaction);
+			await this.armTransaction(transaction, view, Date.now());
+		});
+	}
+	async markIncomplete(transaction, key, stored) {
+		await transaction.put(key, {
+			...stored,
+			session: {
+				...stored.session,
+				telemetryIncomplete: true
+			}
+		});
+	}
+	async admitSession(transaction, key, session, expiresAt, now) {
+		const encoded = new TextEncoder().encode(JSON.stringify({
+			version: 1,
+			expiresAt,
+			session
+		}));
+		if (encoded.byteLength > SESSION_MAX_BYTES) return false;
+		let rows = 0;
+		let bytes = 0;
+		for (const item of await transaction.list("adapter:session:")) {
+			if (item.key === key) continue;
+			if (item.value.expiresAt <= now) {
+				await transaction.delete(item.key);
+				continue;
+			}
+			rows += 1;
+			bytes += new TextEncoder().encode(JSON.stringify(item.value)).byteLength;
+		}
+		return rows < SESSION_MAX_ROWS && bytes + encoded.byteLength <= SESSION_MAX_BYTES_TOTAL;
+	}
+	async batch(traceId, spans, createdAt) {
+		const encoded = new TextEncoder().encode(encodeTraceBatch(spans, {
+			agentId: this.env.RUNTYPE_AGENT_ID,
+			adapterVersion: version
+		}));
+		const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", encoded.slice().buffer));
+		return {
+			version: 1,
+			deliveryId: `${traceId}:${Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("")}`,
+			body: encoded,
+			createdAt
+		};
+	}
+	diagnosticKey(diagnostic) {
+		if (diagnostic === "identity_conflict") return "identityConflict";
+		if (diagnostic === "session_limit") return "sessionLimit";
+		if (diagnostic === "missing_operation_start") return "missingOperationStart";
+		if (diagnostic === "incomplete") return "incomplete";
+		return "unsupported";
+	}
+	async recordDiagnostic(transaction, key) {
+		const current = await transaction.get(diagnosticsKey) ?? {
+			accepted: 0,
+			duplicate: 0,
+			missingSession: 0,
+			identityConflict: 0,
+			sessionLimit: 0,
+			missingOperationStart: 0,
+			incomplete: 0,
+			unsupported: 0,
+			outboxRefused: 0,
+			expired: 0,
+			rejected: 0,
+			pendingRows: 0,
+			pendingBytes: 0,
+			failureCounts: {}
+		};
+		current[key] += 1;
+		await transaction.put(diagnosticsKey, current);
+	}
+	async send(delivery) {
+		let result;
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), 2e4);
+		try {
+			result = await classifyDeliveryResponse(await fetch(createOtlpDeliveryRequest({
+				baseUrl: this.env.RUNTYPE_BASE_URL,
+				apiKey: this.env.RUNTYPE_API_KEY,
+				agentId: this.env.RUNTYPE_AGENT_ID,
+				body: delivery.body,
+				signal: controller.signal
+			})));
+		} catch (error) {
+			result = {
+				kind: "retry",
+				code: this.networkFailureCode(error)
+			};
+		} finally {
+			clearTimeout(timeout);
+		}
+		await this.ctx.storage.transaction(async (transaction) => {
+			const view = this.storage.transactionView(transaction);
+			await this.outbox.settleTransaction(view, delivery, result, Date.now());
+			await this.armTransaction(transaction, view, Date.now());
+		});
+	}
+	networkFailureCode(error) {
+		if (error instanceof Error && error.name === "AbortError") return "network_abort_error";
+		if (error instanceof Error && error.name === "TypeError") return "network_type_error";
+		return "network_unknown_error";
+	}
+	async armTransaction(storage, view, now) {
+		let due = await this.outbox.nextDueTransaction(view, now);
+		for (const item of await view.list("adapter:session:")) if (item.value.expiresAt <= now) await view.delete(item.key);
+		else due = due === void 0 ? item.value.expiresAt : Math.min(due, item.value.expiresAt);
+		if (due === void 0) await storage.deleteAlarm();
+		else await storage.setAlarm(Math.max(now + 1e3, due));
+	}
+};
+//#endregion
+export { RuntypeOtlpOutbox };
+