@tangle-network/agent-runtime 0.104.0 → 0.106.0

package/dist/conversation-XucG_K3l.js

@@ -0,0 +1,1265 @@
+import { r as BackendTransportError, u as ValidationError } from "./errors-DEAvWQPy.js";
+import { a as InMemoryRuntimeSessionStore, c as startOrResumeRuntimeSession, o as newRuntimeSession, s as nowIso, t as createIterableBackend } from "./backends-Dy8NujB4.js";
+//#region src/conversation/call-policy.ts
+/** Thrown when the circuit breaker is open for a participant and no retry is allowed yet. */
+var CircuitOpenError = class extends Error {
+	constructor(participant, retryAfterMs) {
+		super(`circuit open for participant '${participant}'; ${retryAfterMs}ms remaining before retry allowed`);
+		this.name = "CircuitOpenError";
+	}
+};
+/** Thrown when a backend call exceeds its per-attempt deadline. */
+var DeadlineExceededError = class extends Error {
+	constructor(deadlineMs) {
+		super(`backend call exceeded per-attempt deadline of ${deadlineMs}ms`);
+		this.name = "DeadlineExceededError";
+	}
+};
+/**
+* Default retryable classification — network/timeout class errors. Errors
+* a model deliberately throws (validation, refusal, 4xx) are not retried;
+* those represent real outcomes, not transient infrastructure faults.
+*/
+const defaultIsRetryable = (err) => {
+	if (err instanceof DeadlineExceededError) return true;
+	if (err instanceof Error) {
+		const name = err.name;
+		const message = err.message.toLowerCase();
+		if (name === "AbortError" || name === "TimeoutError") return true;
+		if (message.includes("econnreset") || message.includes("etimedout") || message.includes("econnrefused") || message.includes("socket hang up") || message.includes("network") || message.includes("fetch failed")) return true;
+	}
+	return false;
+};
+/** Live circuit-breaker state — one instance per (participant, conversation run). */
+var CircuitBreakerState = class {
+	config;
+	consecutiveFailures = 0;
+	openedAt;
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Check whether the next call is allowed. Throws `CircuitOpenError` when
+	* the breaker is open and the cooldown hasn't elapsed.
+	*/
+	preflight(participant, now = Date.now()) {
+		if (!this.config || this.openedAt === void 0) return;
+		const remaining = this.config.cooldownMs - (now - this.openedAt);
+		if (remaining > 0) throw new CircuitOpenError(participant, remaining);
+		this.openedAt = void 0;
+		this.consecutiveFailures = 0;
+	}
+	recordSuccess() {
+		this.consecutiveFailures = 0;
+		this.openedAt = void 0;
+	}
+	recordFailure(now = Date.now()) {
+		if (!this.config) return;
+		this.consecutiveFailures += 1;
+		if (this.consecutiveFailures >= this.config.failuresToOpen) this.openedAt = now;
+	}
+};
+/**
+* Build a per-attempt AbortSignal linked to the parent signal AND fired when
+* the deadline elapses. The returned `dispose()` MUST be called in a
+* `finally` (clears the timer, detaches the listener) so we don't leak.
+*
+* When the deadline fires, the signal's `reason` is a `DeadlineExceededError`
+* — callers can detect timeout-vs-cancel by reading `signal.reason` after
+* the underlying operation throws.
+*/
+function makePerAttemptSignal(parentSignal, deadlineMs) {
+	const controller = new AbortController();
+	let deadlineError;
+	const cleanups = [];
+	if (parentSignal) if (parentSignal.aborted) controller.abort(parentSignal.reason);
+	else {
+		const onAbort = () => controller.abort(parentSignal.reason);
+		parentSignal.addEventListener("abort", onAbort, { once: true });
+		cleanups.push(() => parentSignal.removeEventListener("abort", onAbort));
+	}
+	if (deadlineMs !== void 0) {
+		const ms = deadlineMs;
+		const timer = setTimeout(() => {
+			deadlineError = new DeadlineExceededError(ms);
+			controller.abort(deadlineError);
+		}, ms);
+		cleanups.push(() => clearTimeout(timer));
+	}
+	return {
+		signal: controller.signal,
+		dispose() {
+			for (const c of cleanups) c();
+		},
+		getDeadlineError() {
+			return deadlineError;
+		}
+	};
+}
+/** Compute the delay before the next attempt. Default: 250ms exponential with jitter. */
+function computeBackoff(spec, attempt) {
+	if (spec === void 0) {
+		const base = 250;
+		const jitter = Math.floor(Math.random() * base);
+		return base * 2 ** (attempt - 1) + jitter;
+	}
+	if (typeof spec === "function") return Math.max(0, spec(attempt));
+	return Math.max(0, spec);
+}
+/** Resolve after `ms` milliseconds — used for retry backoff in conversation call policy. */
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+//#region src/conversation/headers.ts
+/**
+*
+* Cross-gateway forwarding headers — the wire-level contract that makes
+* agent-to-agent communication composable across organizational boundaries.
+* Every header here is read on inbound and re-emitted on outbound, so a chain
+* `caller → A's gateway → A's runtime → B's gateway → B's runtime` ends with
+* B billing the original user, the depth counter monotonically incremented,
+* and the run/turn correlation IDs preserved end-to-end.
+*
+* The actual depth refusal (HTTP 413 at MAX_DEPTH) is enforced by
+* `agent-gateway`'s middleware; this module owns the names + the propagation
+* rules so both sides agree.
+*
+* Full protocol: `docs/agent-bus-protocol.md`.
+*
+* @stable
+*/
+/** Standard names — lowercased so Headers maps interop on every runtime. */
+const FORWARD_HEADERS = {
+	/** Forwarded original-user identity (`Bearer sk-tan-<user>`); downstream gateways bill against this. */
+	authorization: "x-tangle-forwarded-authorization",
+	/** Monotonically incremented on every gateway hop. Refused at MAX_DEPTH. */
+	depth: "x-tangle-forwarded-depth",
+	/** Top-level conversation run identifier, propagated through every nested call. */
+	runId: "x-tangle-runid",
+	/** This call's turn within the run; deterministic + stable across retries. */
+	turnId: "x-tangle-turnid",
+	/** When the call is *inside* another turn (recursion), the parent turn's id. */
+	parentTurnId: "x-tangle-parent-turnid",
+	/** Logical conversation peer label at the sending side, for trace stitching. */
+	speaker: "x-tangle-speaker"
+};
+/** Hard cap on chained gateway hops; refused beyond this. Default keeps recursion bounded. */
+const DEFAULT_MAX_DEPTH = 4;
+/**
+* Lowercase a header lookup so we read the same key regardless of source
+* casing (Hono, fetch's `Headers`, raw Node IncomingMessage, …).
+*/
+function lc(name) {
+	return name.toLowerCase();
+}
+/**
+* Read the depth counter off an inbound request. Missing → 0 (caller is the
+* origin). Non-integer → throws — silent coercion would let a bad caller
+* reset depth and bypass the limit.
+*/
+function readDepth(headers) {
+	const raw = pickHeader(headers, FORWARD_HEADERS.depth);
+	if (raw === void 0 || raw === "") return 0;
+	const n = Number(raw);
+	if (!Number.isInteger(n) || n < 0) throw new Error(`invalid ${FORWARD_HEADERS.depth} header value '${raw}' — must be a non-negative integer`);
+	return n;
+}
+/**
+* Refuse further forwarding when the inbound depth has reached the limit.
+* Callers (the gateway middleware) translate the boolean to an HTTP 413.
+*/
+function isDepthExceeded(inboundDepth, max = 4) {
+	return inboundDepth >= max;
+}
+/**
+* Build the headers to emit on an outbound participant call, given the
+* conversation's propagation context. Depth is incremented from the inbound
+* value; runId / turnId / speaker stamp the current hop; the user's
+* `Authorization` is preserved verbatim so the downstream gateway bills the
+* right wallet.
+*/
+function buildForwardHeaders(input) {
+	const out = {
+		[FORWARD_HEADERS.depth]: String(input.inboundDepth + 1),
+		[FORWARD_HEADERS.runId]: input.runId,
+		[FORWARD_HEADERS.turnId]: input.turnId,
+		[FORWARD_HEADERS.speaker]: input.speaker
+	};
+	if (input.forwardedAuthorization !== void 0) out[FORWARD_HEADERS.authorization] = input.forwardedAuthorization;
+	if (input.parentTurnId !== void 0) out[FORWARD_HEADERS.parentTurnId] = input.parentTurnId;
+	return out;
+}
+function pickHeader(headers, name) {
+	const target = lc(name);
+	for (const key of Object.keys(headers)) if (lc(key) === target) {
+		const value = headers[key];
+		if (Array.isArray(value)) return value[0];
+		return value;
+	}
+}
+//#endregion
+//#region src/conversation/turn-id.ts
+/**
+*
+* Deterministic turn identifier. Stable across retries of the same logical
+* turn so backends (and any caching gateway in between) can dedupe on it.
+* A retry triggered by a network blip or deadline timeout MUST produce the
+* same `turn_id`; only the underlying attempt count differs.
+*
+* Shape: `${runId}.t${index}.${speakerSlug}` — readable in logs, sortable by
+* turn index, attributable to a speaker. Slugify keeps the speaker portion
+* URL-safe so it can ride in HTTP headers without escaping.
+*
+* @stable
+*/
+function turnId(runId, index, speaker) {
+	return `${runId}.t${index}.${slugifySpeaker(speaker)}`;
+}
+/**
+* Reduce a speaker name to ASCII alphanumerics + dashes. Preserves enough
+* substance to read in a log line; collisions between speakers within a
+* single Conversation are prevented by `defineConversation`'s
+* unique-name check, so the slug only needs to be deterministic, not unique.
+*/
+function slugifySpeaker(speaker) {
+	return speaker.normalize("NFKD").replace(/[^\w-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase() || "anon";
+}
+//#endregion
+//#region src/conversation/run-conversation.ts
+/** Run a conversation to completion and return its terminal result. */
+async function runConversation(conversation, options) {
+	let result;
+	for await (const event of runConversationStream(conversation, options)) {
+		if (options.onEvent) await options.onEvent(event);
+		if (event.type === "conversation_end") result = event.result;
+	}
+	if (!result) throw new BackendTransportError("conversation", "conversation stream ended without a conversation_end event");
+	return result;
+}
+/** Streaming conversation orchestrator: drives N participants in turn through their own backends, enforcing `maxTurns` / `maxCreditsCents` / `haltOn`, yielding per-event stream markers. */
+async function* runConversationStream(conversation, options) {
+	const runId = options.runId ?? `conv_${crypto.randomUUID()}`;
+	const inboundDepth = options.inboundDepth ?? 0;
+	const forwardedAuthorization = (options.propagatedHeaders ?? {})[FORWARD_HEADERS.authorization];
+	const breakers = /* @__PURE__ */ new Map();
+	for (const participant of conversation.participants) {
+		const cfg = participant.callPolicy?.circuitBreaker ?? conversation.policy.defaultCallPolicy?.circuitBreaker;
+		breakers.set(participant.name, new CircuitBreakerState(cfg));
+	}
+	let transcript = [];
+	let spentCreditsCents = 0;
+	let startedAt = nowIso();
+	let resumed = false;
+	const sessionStore = options.sessionStore ?? new InMemoryRuntimeSessionStore();
+	if (options.journal) {
+		const prior = await options.journal.loadRun(runId);
+		if (prior) {
+			if (prior.halted) {
+				const replayResult = {
+					runId,
+					transcript: prior.turns,
+					turns: prior.turns.length,
+					spentCreditsCents: prior.turns.reduce((sum, t) => sum + centsFromUsd(t.usage?.costUsd ?? 0), 0),
+					halted: prior.halted,
+					durationMs: 0,
+					startedAt: prior.startedAt,
+					endedAt: prior.endedAt ?? prior.startedAt
+				};
+				yield {
+					type: "conversation_resumed",
+					runId,
+					participants: conversation.participants.map((p) => p.name),
+					transcript: prior.turns,
+					timestamp: nowIso()
+				};
+				yield {
+					type: "conversation_end",
+					runId,
+					result: replayResult,
+					timestamp: nowIso()
+				};
+				return;
+			}
+			transcript = [...prior.turns];
+			spentCreditsCents = transcript.reduce((sum, t) => sum + centsFromUsd(t.usage?.costUsd ?? 0), 0);
+			startedAt = prior.startedAt;
+			resumed = true;
+		} else await options.journal.beginRun(runId, startedAt);
+	}
+	const startedAtMs = Date.now();
+	const participantSessions = sessionIdsFrom(transcript);
+	if (resumed) yield {
+		type: "conversation_resumed",
+		runId,
+		participants: conversation.participants.map((p) => p.name),
+		transcript: [...transcript],
+		timestamp: nowIso()
+	};
+	else yield {
+		type: "conversation_start",
+		runId,
+		participants: conversation.participants.map((p) => p.name),
+		seed: options.seed,
+		timestamp: startedAt
+	};
+	let currentInput = transcript.length === 0 ? options.seed : transcript[transcript.length - 1]?.text ?? options.seed;
+	let halt;
+	const initialOffset = transcript.length;
+	for (let turnIndex = initialOffset; turnIndex < conversation.policy.maxTurns; turnIndex++) {
+		if (options.signal?.aborted) {
+			halt = { kind: "abort" };
+			break;
+		}
+		if (conversation.policy.maxCreditsCents !== void 0 && spentCreditsCents >= conversation.policy.maxCreditsCents) {
+			halt = {
+				kind: "max_credits",
+				spentCents: spentCreditsCents,
+				capCents: conversation.policy.maxCreditsCents
+			};
+			break;
+		}
+		const speakerIdx = selectSpeaker(conversation.policy.turnOrder, conversation.participants.length, {
+			transcript,
+			turnIndex,
+			spentCreditsCents
+		});
+		const speaker = conversation.participants[speakerIdx];
+		if (!speaker) throw new BackendTransportError("conversation", `turnOrder selector returned out-of-range index ${speakerIdx} for ${conversation.participants.length} participants`);
+		const tid = turnId(runId, turnIndex, speaker.name);
+		const callPolicy = speaker.callPolicy ?? conversation.policy.defaultCallPolicy;
+		const breaker = breakers.get(speaker.name);
+		if (!breaker) throw new BackendTransportError("conversation", `internal: no circuit-breaker state registered for participant '${speaker.name}'`);
+		const isRetryable = callPolicy?.isRetryable ?? defaultIsRetryable;
+		const totalAttempts = 1 + (callPolicy?.maxRetries ?? 0);
+		yield {
+			type: "turn_start",
+			runId,
+			index: turnIndex,
+			speaker: speaker.name,
+			turnId: tid,
+			attempt: 1,
+			timestamp: nowIso()
+		};
+		let aggregator;
+		let attemptCount = 0;
+		let lastError;
+		let breakerOpenFailure;
+		for (let attempt = 1; attempt <= totalAttempts; attempt++) {
+			attemptCount = attempt;
+			try {
+				breaker.preflight(speaker.name);
+			} catch (err) {
+				breakerOpenFailure = err;
+				break;
+			}
+			if (attempt > 1) yield {
+				type: "turn_retry",
+				runId,
+				index: turnIndex,
+				speaker: speaker.name,
+				turnId: tid,
+				attempt,
+				reason: lastError instanceof Error ? lastError.message : String(lastError),
+				timestamp: nowIso()
+			};
+			const perAttempt = makePerAttemptSignal(options.signal, callPolicy?.perAttemptDeadlineMs);
+			const localAgg = new TurnAggregator({
+				index: turnIndex,
+				speaker: speaker.name,
+				startedAt: nowIso()
+			});
+			try {
+				for await (const delta of driveSingleAttempt({
+					speaker,
+					participants: conversation.participants,
+					seed: options.seed,
+					input: currentInput,
+					turnIndex,
+					runId,
+					turnId: tid,
+					transcript,
+					participantSessions,
+					sessionStore,
+					signal: perAttempt.signal,
+					aggregator: localAgg,
+					propagatedHeaders: buildForwardHeaders({
+						inboundDepth,
+						forwardedAuthorization: resolveAuthForwarding(speaker, {
+							transcript,
+							turnIndex,
+							spentCreditsCents
+						}) ? forwardedAuthorization : void 0,
+						runId,
+						turnId: tid,
+						parentTurnId: options.parentTurnId,
+						speaker: speaker.name
+					})
+				})) yield {
+					type: "turn_text_delta",
+					runId,
+					index: turnIndex,
+					speaker: speaker.name,
+					turnId: tid,
+					text: delta.text,
+					timestamp: delta.timestamp
+				};
+				perAttempt.dispose();
+				breaker.recordSuccess();
+				aggregator = localAgg;
+				break;
+			} catch (err) {
+				perAttempt.dispose();
+				breaker.recordFailure();
+				lastError = perAttempt.getDeadlineError() ?? err;
+				if (attempt >= totalAttempts || !isRetryable(lastError)) break;
+				await sleep(computeBackoff(callPolicy?.retryBackoffMs, attempt));
+			}
+		}
+		if (!aggregator) {
+			const failure = breakerOpenFailure ?? lastError;
+			const message = failure instanceof Error ? failure.message : String(failure);
+			halt = {
+				kind: "participant_error",
+				participant: speaker.name,
+				message
+			};
+			break;
+		}
+		const turn = aggregator.toTurn({
+			turnId: tid,
+			attempts: attemptCount
+		});
+		if (turn.sessionId) bindParticipantSession(participantSessions, turn.speaker, turn.sessionId);
+		transcript.push(turn);
+		spentCreditsCents += centsFromUsd(turn.usage?.costUsd ?? 0);
+		if (options.journal) await options.journal.appendTurn(runId, turn);
+		yield {
+			type: "turn_end",
+			runId,
+			turn,
+			timestamp: nowIso()
+		};
+		if (conversation.policy.haltOn) {
+			const haltCtx = {
+				transcript,
+				lastTurn: turn,
+				turnIndex,
+				spentCreditsCents
+			};
+			const decision = await conversation.policy.haltOn(haltCtx);
+			if (decision === true) {
+				halt = {
+					kind: "predicate",
+					reason: "predicate_true"
+				};
+				break;
+			}
+			if (typeof decision === "object" && decision !== null && decision.halted) {
+				halt = {
+					kind: "predicate",
+					reason: decision.reason
+				};
+				break;
+			}
+		}
+		currentInput = turn.text;
+	}
+	if (!halt) halt = {
+		kind: "max_turns",
+		turns: transcript.length
+	};
+	const endedAt = nowIso();
+	const result = {
+		runId,
+		transcript,
+		turns: transcript.length,
+		spentCreditsCents,
+		halted: halt,
+		durationMs: Date.now() - startedAtMs,
+		startedAt,
+		endedAt
+	};
+	if (options.journal) await options.journal.recordHalt(runId, halt, endedAt);
+	yield {
+		type: "conversation_end",
+		runId,
+		result,
+		timestamp: endedAt
+	};
+}
+async function* driveSingleAttempt(args) {
+	const task = {
+		id: args.turnId,
+		intent: args.input,
+		metadata: {
+			runId: args.runId,
+			turnId: args.turnId,
+			turnIndex: args.turnIndex,
+			speaker: args.speaker.name,
+			participants: args.participants.map((p) => p.name)
+		}
+	};
+	const knowledge = passingReadiness(task.id);
+	const startCtx = {
+		task,
+		knowledge,
+		signal: args.signal,
+		runId: args.runId,
+		turnId: args.turnId,
+		propagatedHeaders: args.propagatedHeaders
+	};
+	const previousSessionId = args.participantSessions.get(args.speaker.name);
+	const opened = await startOrResumeRuntimeSession({
+		backend: args.speaker.backend,
+		input: () => fullConversationInput(task, args.speaker.name, args.seed, args.transcript),
+		continuationInput: () => continuedConversationInput(task, args.speaker.name, args.transcript),
+		context: startCtx,
+		store: args.sessionStore,
+		sessionId: previousSessionId ?? participantSessionId(args.runId, args.speaker.name, args.participants),
+		resume: previousSessionId !== void 0 && args.speaker.backend.resume !== void 0,
+		validateSession: (session) => assertParticipantSessionAvailable(args.participantSessions, args.speaker.name, session.id)
+	});
+	const session = opened.session;
+	args.aggregator.recordSession(session.id);
+	const streamCtx = {
+		task,
+		knowledge,
+		session,
+		signal: args.signal,
+		runId: args.runId,
+		turnId: args.turnId,
+		propagatedHeaders: args.propagatedHeaders
+	};
+	for await (const event of args.speaker.backend.stream(opened.input, streamCtx)) {
+		if (args.signal.aborted) {
+			const reason = args.signal.reason;
+			throw reason instanceof Error ? reason : /* @__PURE__ */ new Error("aborted");
+		}
+		if (event.type === "text_delta") {
+			args.aggregator.appendText(event.text);
+			yield {
+				text: event.text,
+				timestamp: event.timestamp
+			};
+		} else if (event.type === "llm_call") args.aggregator.recordUsage(event);
+		else if (event.type === "backend_error") throw new BackendTransportError(args.speaker.backend.kind, event.message, {
+			status: event.error?.status,
+			body: event.error?.body
+		});
+		else if (event.type === "final") {
+			if (event.status !== "completed") throw new BackendTransportError(args.speaker.backend.kind, event.error?.message ?? event.reason, {
+				status: event.error?.status,
+				body: event.error?.body
+			});
+			args.aggregator.adoptFinalText(event.text);
+		}
+	}
+	if (!args.aggregator.hasText()) throw new BackendTransportError(args.speaker.backend.kind, `backend '${args.speaker.backend.kind}' completed without text`);
+}
+var TurnAggregator = class {
+	base;
+	text = "";
+	adoptedFinal = false;
+	sessionId;
+	usage;
+	constructor(base) {
+		this.base = base;
+	}
+	appendText(text) {
+		if (this.adoptedFinal) return;
+		this.text += text;
+	}
+	/**
+	* Use the backend's `final.text` only when no streamed deltas were observed.
+	* Some backends emit deltas AND a final summary; treating both as content
+	* would double-count.
+	*/
+	adoptFinalText(text) {
+		if (!text) return;
+		if (this.text.length > 0) return;
+		this.text = text;
+		this.adoptedFinal = true;
+	}
+	hasText() {
+		return this.text.trim().length > 0;
+	}
+	recordSession(sessionId) {
+		this.sessionId = sessionId;
+	}
+	recordUsage(event) {
+		const u = this.usage ?? {};
+		if (event.tokensIn !== void 0) u.tokensIn = (u.tokensIn ?? 0) + event.tokensIn;
+		if (event.tokensOut !== void 0) u.tokensOut = (u.tokensOut ?? 0) + event.tokensOut;
+		if (event.costUsd !== void 0) u.costUsd = (u.costUsd ?? 0) + event.costUsd;
+		if (event.latencyMs !== void 0) u.latencyMs = event.latencyMs;
+		if (event.model !== void 0) u.model = event.model;
+		this.usage = u;
+	}
+	toTurn(meta) {
+		return {
+			index: this.base.index,
+			speaker: this.base.speaker,
+			turnId: meta.turnId,
+			...this.sessionId ? { sessionId: this.sessionId } : {},
+			text: this.text.trim(),
+			usage: this.usage,
+			attempts: meta.attempts,
+			startedAt: this.base.startedAt,
+			endedAt: nowIso()
+		};
+	}
+};
+/**
+* Build the participant's POV of the transcript so an OpenAI-compatible
+* backend sees its own turns as `assistant` and everyone else's as `user`,
+* with explicit speaker tags so 3+ party conversations stay disambiguated.
+*/
+function buildMessagesFor(speakerName, seed, transcript) {
+	const messages = seed ? [{
+		role: "user",
+		content: seed
+	}] : [];
+	for (const turn of transcript) if (turn.speaker === speakerName) messages.push({
+		role: "assistant",
+		content: turn.text
+	});
+	else messages.push({
+		role: "user",
+		content: `[${turn.speaker}] ${turn.text}`
+	});
+	return messages;
+}
+function fullConversationInput(task, speakerName, seed, transcript) {
+	return {
+		task,
+		message: [seed, ...transcript.map((turn) => `[${turn.speaker}] ${turn.text}`)].filter((part) => part.length > 0).join("\n\n"),
+		messages: buildMessagesFor(speakerName, seed, transcript)
+	};
+}
+function continuedConversationInput(task, speakerName, transcript) {
+	let lastOwnTurn = -1;
+	for (let index = transcript.length - 1; index >= 0; index -= 1) if (transcript[index]?.speaker === speakerName) {
+		lastOwnTurn = index;
+		break;
+	}
+	const unseen = transcript.slice(lastOwnTurn + 1);
+	const message = unseen.length > 0 ? unseen.map((turn) => `[${turn.speaker}] ${turn.text}`).join("\n\n") : "Continue.";
+	return {
+		task,
+		message,
+		messages: [{
+			role: "user",
+			content: message
+		}]
+	};
+}
+function sessionIdsFrom(transcript) {
+	const sessions = /* @__PURE__ */ new Map();
+	for (const turn of transcript) if (turn.sessionId) bindParticipantSession(sessions, turn.speaker, turn.sessionId);
+	return sessions;
+}
+function bindParticipantSession(sessions, speakerName, sessionId) {
+	assertParticipantSessionAvailable(sessions, speakerName, sessionId);
+	sessions.set(speakerName, sessionId);
+}
+function assertParticipantSessionAvailable(sessions, speakerName, sessionId) {
+	for (const [boundSpeaker, boundSessionId] of sessions) if (boundSpeaker !== speakerName && boundSessionId === sessionId) throw new BackendTransportError("conversation", `session '${sessionId}' is already bound to participant '${boundSpeaker}'`);
+}
+function participantSessionId(runId, speakerName, participants) {
+	const participantIndex = participants.findIndex((participant) => participant.name === speakerName);
+	if (participantIndex < 0) throw new BackendTransportError("conversation", `participant '${speakerName}' is not registered in this conversation`);
+	return `${runId}.participant.${participantIndex}.${slugifySpeaker(speakerName)}`;
+}
+/**
+* True when this participant should forward the caller's
+* `X-Tangle-Forwarded-Authorization` on outbound calls (the "pass-through"
+* commercial mode). False when it elects to pay for its own outbound calls
+* (the "reseller" / "bundle" mode). See ConversationParticipant.authSource.
+*/
+function resolveAuthForwarding(participant, state) {
+	return (typeof participant.authSource === "function" ? participant.authSource(state) : participant.authSource ?? "forward-user") === "forward-user";
+}
+function selectSpeaker(order, participantCount, state) {
+	const resolved = order ?? (participantCount === 2 ? "alternate" : "round-robin");
+	if (resolved === "alternate" || resolved === "round-robin") return state.turnIndex % participantCount;
+	if (typeof resolved === "function") {
+		const idx = resolved(state);
+		if (!Number.isInteger(idx) || idx < 0 || idx >= participantCount) throw new BackendTransportError("conversation", `turnOrder function returned invalid index ${String(idx)} for ${participantCount} participants`);
+		return idx;
+	}
+	throw new BackendTransportError("conversation", `unknown turnOrder: ${String(resolved)}`);
+}
+function centsFromUsd(usd) {
+	return Math.round(usd * 100);
+}
+/**
+* Synthesize a knowledge-readiness report that *passes* every gate, used to
+* satisfy `AgentBackendContext.knowledge` per turn. Conversations don't apply
+* task-level readiness gating per-turn — that's a `runAgentTask` concern.
+*/
+function passingReadiness(taskId) {
+	return {
+		taskId,
+		readinessScore: 1,
+		blockingMissingRequirements: [],
+		nonBlockingGaps: [],
+		recommendedAction: "run_agent",
+		bundle: {
+			taskId,
+			requirements: [],
+			evidenceIds: [],
+			claimIds: [],
+			wikiPageIds: [],
+			userAnswers: {},
+			missing: [],
+			readinessScore: 1
+		},
+		severity: "info",
+		reason: "conversation-mode: readiness gating not applied per-turn"
+	};
+}
+//#endregion
+//#region src/conversation/conversation-backend.ts
+/**
+*
+* Wrap a `Conversation` so it satisfies `AgentExecutionBackend`. The result is
+* an addressable "single agent" whose internal behavior is an N-party
+* orchestrated conversation — the recursion primitive that lets a swarm be a
+* participant inside another swarm, or be published behind a single
+* agent-gateway endpoint.
+*
+* Stream events from inner participants are NOT forwarded verbatim. Outer
+* callers see one `text_delta` per inner turn (the turn's full text), tagged
+* with `[speaker] ` prefix so the outer transcript stays attributable. The
+* conversation's `conversation_end` halt reason rides on a `final` event.
+*
+* @stable
+*/
+/** Adapt a multi-participant conversation into the standard execution backend contract. */
+function createConversationBackend(options) {
+	const kind = options.kind ?? "conversation";
+	return {
+		kind,
+		start(_input, context) {
+			return newRuntimeSession(kind, context.requestedSessionId, { participants: options.conversation.participants.map((p) => p.name) });
+		},
+		async *stream(input, context) {
+			const seed = input.message ?? input.messages?.at(-1)?.content ?? context.task.intent;
+			const task = context.task;
+			const session = context.session;
+			yield {
+				type: "backend_start",
+				task,
+				session,
+				backend: kind,
+				timestamp: nowIso()
+			};
+			let finalText = "";
+			let totalCostUsd = 0;
+			let totalTokensIn = 0;
+			let totalTokensOut = 0;
+			const inboundDepth = parseInboundDepth(context.propagatedHeaders);
+			for await (const event of runConversationStream(options.conversation, {
+				seed,
+				signal: context.signal,
+				runId: context.runId,
+				propagatedHeaders: context.propagatedHeaders,
+				inboundDepth,
+				parentTurnId: context.turnId
+			})) if (event.type === "turn_end") {
+				const tagged = `[${event.turn.speaker}] ${event.turn.text}\n`;
+				finalText += tagged;
+				yield {
+					type: "text_delta",
+					task,
+					session,
+					text: tagged,
+					timestamp: event.timestamp
+				};
+				if (event.turn.usage) {
+					const u = event.turn.usage;
+					if (u.costUsd !== void 0) totalCostUsd += u.costUsd;
+					if (u.tokensIn !== void 0) totalTokensIn += u.tokensIn;
+					if (u.tokensOut !== void 0) totalTokensOut += u.tokensOut;
+					yield {
+						type: "llm_call",
+						task,
+						session,
+						model: u.model ?? `${kind}/${event.turn.speaker}`,
+						tokensIn: u.tokensIn,
+						tokensOut: u.tokensOut,
+						costUsd: u.costUsd,
+						latencyMs: u.latencyMs,
+						timestamp: event.timestamp
+					};
+				}
+			} else if (event.type === "conversation_end") {
+				const halt = event.result.halted;
+				yield {
+					type: "final",
+					task,
+					session,
+					status: halt.kind === "participant_error" ? "failed" : "completed",
+					reason: describeHalt(halt),
+					text: finalText.trim(),
+					metadata: {
+						conversationRunId: event.result.runId,
+						turns: event.result.turns,
+						spentCreditsCents: event.result.spentCreditsCents,
+						halted: halt,
+						durationMs: event.result.durationMs,
+						tokensIn: totalTokensIn,
+						tokensOut: totalTokensOut,
+						costUsd: totalCostUsd
+					},
+					timestamp: event.timestamp
+				};
+			}
+			yield {
+				type: "backend_end",
+				task,
+				session,
+				backend: kind,
+				timestamp: nowIso()
+			};
+		}
+	};
+}
+function parseInboundDepth(headers) {
+	if (!headers) return 0;
+	const raw = headers[FORWARD_HEADERS.depth];
+	if (raw === void 0) return 0;
+	try {
+		return readDepth({ [FORWARD_HEADERS.depth]: raw });
+	} catch {
+		return 0;
+	}
+}
+function describeHalt(halt) {
+	switch (halt.kind) {
+		case "max_turns": return `max_turns (${halt.turns})`;
+		case "max_credits": return `max_credits (${halt.spentCents}/${halt.capCents}¢)`;
+		case "predicate": return `predicate: ${halt.reason}`;
+		case "abort": return "abort";
+		case "participant_error": return `participant_error[${halt.participant}]: ${halt.message}`;
+	}
+}
+//#endregion
+//#region src/conversation/define-conversation.ts
+/**
+*
+* Declarative constructor for a multi-agent `Conversation`. Validates inputs
+* fail-loud at definition time (duplicate participant names, alternate order
+* with ≠2 participants, non-positive `maxTurns`) so misconfiguration is caught
+* before `runConversation` is called and not buried inside a streaming run.
+*
+* @stable
+*/
+/** Validate and define a conversation before execution. */
+function defineConversation(input) {
+	if (input.participants.length < 2) throw new ValidationError(`Conversation requires at least 2 participants; received ${input.participants.length}.`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const p of input.participants) {
+		if (!p.name || p.name.trim() === "") throw new ValidationError("Conversation participant.name must be a non-empty string.");
+		if (seen.has(p.name)) throw new ValidationError(`Conversation participant names must be unique within a Conversation; '${p.name}' appears more than once.`);
+		seen.add(p.name);
+		if (!p.backend || typeof p.backend.stream !== "function") throw new ValidationError(`Conversation participant '${p.name}' is missing a backend with a stream() method.`);
+	}
+	const policy = normalizePolicy(input.policy, input.participants.length);
+	return {
+		participants: input.participants,
+		policy
+	};
+}
+function normalizePolicy(policy, participantCount) {
+	if (!Number.isInteger(policy.maxTurns) || policy.maxTurns < 1) throw new ValidationError(`ConversationPolicy.maxTurns must be a positive integer; received ${String(policy.maxTurns)}.`);
+	if (policy.maxCreditsCents !== void 0 && (!Number.isFinite(policy.maxCreditsCents) || policy.maxCreditsCents < 0)) throw new ValidationError(`ConversationPolicy.maxCreditsCents must be a non-negative finite number when set; received ${String(policy.maxCreditsCents)}.`);
+	const turnOrder = policy.turnOrder ?? (participantCount === 2 ? "alternate" : "round-robin");
+	if (turnOrder === "alternate" && participantCount !== 2) throw new ValidationError(`ConversationPolicy.turnOrder 'alternate' requires exactly 2 participants; received ${participantCount}. Use 'round-robin' or a custom selector for N-party conversations.`);
+	return {
+		...policy,
+		turnOrder
+	};
+}
+//#endregion
+//#region src/conversation/journal.ts
+/** In-memory `ConversationJournal` — suitable for testing and single-process runs. */
+var InMemoryConversationJournal = class {
+	entries = /* @__PURE__ */ new Map();
+	async loadRun(runId) {
+		const entry = this.entries.get(runId);
+		if (!entry) return void 0;
+		return {
+			runId: entry.runId,
+			startedAt: entry.startedAt,
+			halted: entry.halted,
+			endedAt: entry.endedAt,
+			turns: [...entry.turns]
+		};
+	}
+	async beginRun(runId, startedAt) {
+		const existing = this.entries.get(runId);
+		if (existing) {
+			if (existing.startedAt !== startedAt) throw new Error(`runId '${runId}' already exists with startedAt=${existing.startedAt}; refusing to overwrite with ${startedAt}`);
+			return;
+		}
+		this.entries.set(runId, {
+			runId,
+			startedAt,
+			turns: []
+		});
+	}
+	async appendTurn(runId, turn) {
+		const entry = this.entries.get(runId);
+		if (!entry) throw new Error(`appendTurn called for unknown runId '${runId}'; call beginRun first or use the runner which handles it`);
+		if (entry.halted) throw new Error(`cannot append turn to halted run '${runId}' (halt reason: ${JSON.stringify(entry.halted)})`);
+		entry.turns.push(turn);
+	}
+	async recordHalt(runId, halt, endedAt) {
+		const entry = this.entries.get(runId);
+		if (!entry) throw new Error(`recordHalt called for unknown runId '${runId}'`);
+		entry.halted = halt;
+		entry.endedAt = endedAt;
+	}
+};
+/**
+* JSONL on disk. One line per record; first line is the `begin`, subsequent
+* lines are `turn` records, terminal line is `halt`. Replays the whole file
+* on `loadRun` — cheap for the conversation sizes this is designed for
+* (thousands of turns, not millions). For huge runs, plug in a real DB
+* adapter; the interface is small.
+*
+* Each `appendTurn` / `recordHalt` calls `fsync` after the write so a
+* process crash between writes never loses an acknowledged turn.
+*/
+var FileConversationJournal = class {
+	path;
+	constructor(path) {
+		this.path = path;
+	}
+	async loadRun(runId) {
+		const fs = await import("node:fs/promises");
+		let text;
+		try {
+			text = await fs.readFile(this.path, "utf8");
+		} catch (err) {
+			if (isNoEntError(err)) return void 0;
+			throw err;
+		}
+		const lines = text.split("\n").filter((line) => line.length > 0);
+		let entry;
+		for (const line of lines) {
+			const record = JSON.parse(line);
+			if (record.runId !== runId) continue;
+			if (record.kind === "begin") entry = {
+				runId,
+				startedAt: record.startedAt,
+				turns: []
+			};
+			else if (record.kind === "turn") {
+				if (!entry) throw new Error(`journal corrupted: turn record for runId '${runId}' precedes its begin record`);
+				entry.turns.push(record.turn);
+			} else if (record.kind === "halt") {
+				if (!entry) throw new Error(`journal corrupted: halt record for runId '${runId}' precedes its begin record`);
+				entry.halted = record.halted;
+				entry.endedAt = record.endedAt;
+			}
+		}
+		return entry;
+	}
+	async beginRun(runId, startedAt) {
+		const existing = await this.loadRun(runId);
+		if (existing) {
+			if (existing.startedAt !== startedAt) throw new Error(`runId '${runId}' already exists in ${this.path} with startedAt=${existing.startedAt}; refusing to overwrite with ${startedAt}`);
+			return;
+		}
+		await this.appendRecord({
+			kind: "begin",
+			runId,
+			startedAt
+		});
+	}
+	async appendTurn(runId, turn) {
+		await this.appendRecord({
+			kind: "turn",
+			runId,
+			turn
+		});
+	}
+	async recordHalt(runId, halt, endedAt) {
+		await this.appendRecord({
+			kind: "halt",
+			runId,
+			halted: halt,
+			endedAt
+		});
+	}
+	async appendRecord(record) {
+		const fs = await import("node:fs/promises");
+		const path = await import("node:path");
+		await fs.mkdir(path.dirname(this.path), { recursive: true });
+		const fh = await fs.open(this.path, "a");
+		try {
+			await fh.write(`${JSON.stringify(record)}\n`);
+			await fh.sync();
+		} finally {
+			await fh.close();
+		}
+	}
+};
+function isNoEntError(err) {
+	return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+//#endregion
+//#region src/conversation/journal-sql.ts
+/**
+* Adapt a Cloudflare D1 binding to the SqlAdapter shape. Lives here so D1
+* consumers don't have to write the wrapper themselves; the runtime never
+* imports `@cloudflare/workers-types` directly (peer-style typing).
+*/
+function d1ToSqlAdapter(db) {
+	return {
+		async exec(sql, params = []) {
+			const stmt = db.prepare(sql);
+			const meta = (await (params.length > 0 ? stmt.bind(...params) : stmt).run()).meta;
+			return { rowsAffected: meta?.rows_written ?? meta?.changes ?? 0 };
+		},
+		async query(sql, params = []) {
+			const stmt = db.prepare(sql);
+			return (await (params.length > 0 ? stmt.bind(...params) : stmt).all()).results ?? [];
+		}
+	};
+}
+const RUNS_TABLE_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table}_runs (
+    run_id TEXT PRIMARY KEY,
+    started_at TEXT NOT NULL,
+    halted_kind TEXT,
+    halted_payload TEXT,
+    ended_at TEXT
+  )
+`;
+const TURNS_TABLE_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table}_turns (
+    run_id TEXT NOT NULL,
+    turn_index INTEGER NOT NULL,
+    payload TEXT NOT NULL,
+    PRIMARY KEY (run_id, turn_index)
+  )
+`;
+const TURNS_INDEX_DDL = (table) => `
+  CREATE INDEX IF NOT EXISTS idx_${table}_turns_run ON ${table}_turns (run_id, turn_index)
+`;
+/**
+* SQL-backed ConversationJournal. Two tables — runs (one row per runId, holds
+* start/halt timestamps + halt reason) and turns (one row per committed turn,
+* payload is the ConversationTurn JSON). Replays the turns table on
+* `loadRun` and writes append-only per `appendTurn`.
+*/
+var SqlConversationJournal = class {
+	db;
+	table;
+	/**
+	* @param db    SQL adapter (D1, postgres, sqlite, libSQL — all work)
+	* @param table Table-name prefix; the journal creates `${table}_runs` and
+	*              `${table}_turns`. Lets multiple journals share a database
+	*              without colliding (e.g. one per product surface).
+	*/
+	constructor(db, table = "agent_runtime_journal") {
+		this.db = db;
+		this.table = table;
+	}
+	/**
+	* Create the journal's tables if absent. Idempotent. Call once at deploy
+	* (or at app boot) — running on every request is harmless but adds latency.
+	*/
+	async migrate() {
+		await this.db.exec(RUNS_TABLE_DDL(this.table));
+		await this.db.exec(TURNS_TABLE_DDL(this.table));
+		await this.db.exec(TURNS_INDEX_DDL(this.table));
+	}
+	async loadRun(runId) {
+		const row = (await this.db.query(`SELECT run_id, started_at, halted_kind, halted_payload, ended_at FROM ${this.table}_runs WHERE run_id = ?`, [runId]))[0];
+		if (!row) return void 0;
+		const turns = await this.db.query(`SELECT payload, turn_index FROM ${this.table}_turns WHERE run_id = ? ORDER BY turn_index ASC`, [runId]);
+		return {
+			runId: row.run_id,
+			startedAt: row.started_at,
+			halted: row.halted_payload ? JSON.parse(row.halted_payload) : void 0,
+			endedAt: row.ended_at ?? void 0,
+			turns: turns.map((t) => JSON.parse(t.payload))
+		};
+	}
+	async beginRun(runId, startedAt) {
+		const existing = await this.db.query(`SELECT started_at FROM ${this.table}_runs WHERE run_id = ?`, [runId]);
+		if (existing.length > 0) {
+			if (existing[0]?.started_at !== startedAt) throw new Error(`runId '${runId}' already exists with startedAt=${existing[0]?.started_at}; refusing to overwrite with ${startedAt}`);
+			return;
+		}
+		await this.db.exec(`INSERT INTO ${this.table}_runs (run_id, started_at) VALUES (?, ?)`, [runId, startedAt]);
+	}
+	async appendTurn(runId, turn) {
+		const halted = await this.db.query(`SELECT halted_kind FROM ${this.table}_runs WHERE run_id = ?`, [runId]);
+		if (halted.length === 0) throw new Error(`appendTurn called for unknown runId '${runId}'; call beginRun first or use the runner which handles it`);
+		if (halted[0]?.halted_kind) throw new Error(`cannot append turn to halted run '${runId}' (halt kind: ${halted[0]?.halted_kind})`);
+		await this.db.exec(`INSERT INTO ${this.table}_turns (run_id, turn_index, payload) VALUES (?, ?, ?)`, [
+			runId,
+			turn.index,
+			JSON.stringify(turn)
+		]);
+	}
+	async recordHalt(runId, halt, endedAt) {
+		if ((await this.db.exec(`UPDATE ${this.table}_runs SET halted_kind = ?, halted_payload = ?, ended_at = ? WHERE run_id = ?`, [
+			halt.kind,
+			JSON.stringify(halt),
+			endedAt,
+			runId
+		])).rowsAffected === 0) throw new Error(`recordHalt called for unknown runId '${runId}'`);
+	}
+};
+//#endregion
+//#region src/conversation/run-persona.ts
+/** Prefix a backend's requests with `systemPrompt`; when `counter` is given,
+*  accumulate its `llm_call` token/cost usage (used for the metered worker). */
+function withProfilePrompt(inner, systemPrompt, counter) {
+	return {
+		kind: inner.kind,
+		start: inner.start ? (input, ctx) => inner.start(input, ctx) : void 0,
+		resume: inner.resume ? (session, input, ctx) => inner.resume(session, input, ctx) : void 0,
+		stop: inner.stop ? (session, reason) => inner.stop(session, reason) : void 0,
+		async *stream(input, context) {
+			const base = input.messages ?? (input.message ? [{
+				role: "user",
+				content: input.message
+			}] : []);
+			const messages = base[0]?.role === "system" ? base : [{
+				role: "system",
+				content: systemPrompt
+			}, ...base];
+			for await (const event of inner.stream({
+				...input,
+				messages
+			}, context)) {
+				if (counter && event.type === "llm_call") {
+					counter.tokensIn += event.tokensIn ?? 0;
+					counter.tokensOut += event.tokensOut ?? 0;
+					counter.costUsd += event.costUsd ?? 0;
+				}
+				yield event;
+			}
+		}
+	};
+}
+/** A persona participant that replays scripted user turns in order. */
+function scriptedPersonaBackend(turns) {
+	let idx = 0;
+	return createIterableBackend({
+		kind: "persona-user",
+		async *stream(_input, context) {
+			const text = turns[idx];
+			if (text === void 0) throw new Error(`persona-user: ran out of scripted turns at index ${idx} (had ${turns.length})`);
+			idx += 1;
+			yield {
+				type: "text_delta",
+				task: context.task,
+				session: context.session,
+				text,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		}
+	});
+}
+/**
+* Run one worker profile against one persona as a multi-round conversation.
+* The persona leads (participant 0): it speaks, the worker answers, repeat,
+* until `maxTurns`. Returns the persistent transcript + worker-only usage.
+*/
+async function runPersonaConversation(opts) {
+	const counter = {
+		tokensIn: 0,
+		tokensOut: 0,
+		costUsd: 0
+	};
+	const workerName = opts.workerName ?? "agent";
+	const worker = withProfilePrompt(opts.backendFor(opts.worker, "worker"), opts.systemPromptOf(opts.worker), counter);
+	let persona;
+	let maxTurns;
+	if (opts.persona.kind === "scripted") {
+		if (opts.persona.turns.length === 0) throw new Error("runPersonaConversation: scripted persona has no turns");
+		persona = scriptedPersonaBackend(opts.persona.turns);
+		maxTurns = opts.maxTurns ?? 2 * opts.persona.turns.length;
+	} else {
+		persona = withProfilePrompt(opts.backendFor(opts.persona.profile, "persona"), opts.systemPromptOf(opts.persona.profile));
+		if (opts.maxTurns === void 0) throw new Error("runPersonaConversation: maxTurns is required for a profile-driven persona");
+		maxTurns = opts.maxTurns;
+	}
+	const result = await runConversation(defineConversation({
+		participants: [{
+			name: "user",
+			backend: persona
+		}, {
+			name: workerName,
+			backend: worker
+		}],
+		policy: {
+			maxTurns,
+			turnOrder: "alternate",
+			...opts.haltOn ? { haltOn: opts.haltOn } : {}
+		}
+	}), {
+		seed: opts.seed ?? "Begin.",
+		signal: opts.signal
+	});
+	const costUsd = counter.costUsd > 0 ? counter.costUsd : opts.persona.kind === "scripted" ? result.spentCreditsCents / 100 : 0;
+	return {
+		transcript: result.transcript,
+		turns: result.turns,
+		halted: result.halted,
+		costUsd,
+		tokensIn: counter.tokensIn,
+		tokensOut: counter.tokensOut
+	};
+}
+/**
+* Wrap {@link runPersonaConversation} as a `ProfileDispatchFn` for
+* `runProfileMatrix`: the profile axis is the worker-under-test, the scenario
+* axis is the persona, and the runner is the cell. Meters the worker through
+* `ctx.cost` so the matrix's backend-integrity guard sees real usage.
+*/
+function runPersonaDispatch(config) {
+	return async (worker, scenario, ctx) => {
+		const model = worker.model?.default ?? "unknown";
+		const maximumCharge = typeof config.maximumCharge === "function" ? config.maximumCharge(worker, scenario) : config.maximumCharge;
+		const paid = await ctx.cost.runPaidCall({
+			channel: "agent",
+			actor: "persona-conversation",
+			model,
+			signal: ctx.signal,
+			...maximumCharge ? { maximumCharge } : {},
+			execute: (executionSignal) => runPersonaConversation({
+				worker,
+				persona: config.personaOf(scenario),
+				backendFor: config.backendFor,
+				systemPromptOf: config.systemPromptOf,
+				maxTurns: config.maxTurns?.(scenario),
+				seed: config.seed?.(scenario),
+				signal: executionSignal,
+				workerName: config.workerName
+			}),
+			receipt: (result) => ({
+				model,
+				inputTokens: result.tokensIn,
+				outputTokens: result.tokensOut,
+				...result.costUsd > 0 ? { actualCostUsd: result.costUsd } : {}
+			})
+		});
+		if (!paid.succeeded) throw paid.error;
+		const result = paid.value;
+		return config.artifactOf(result.transcript, scenario);
+	};
+}
+//#endregion
+export { makePerAttemptSignal as C, defaultIsRetryable as S, readDepth as _, FileConversationJournal as a, DeadlineExceededError as b, createConversationBackend as c, slugifySpeaker as d, turnId as f, isDepthExceeded as g, buildForwardHeaders as h, d1ToSqlAdapter as i, runConversation as l, FORWARD_HEADERS as m, runPersonaDispatch as n, InMemoryConversationJournal as o, DEFAULT_MAX_DEPTH as p, SqlConversationJournal as r, defineConversation as s, runPersonaConversation as t, runConversationStream as u, CircuitBreakerState as v, sleep as w, computeBackoff as x, CircuitOpenError as y };
+
+//# sourceMappingURL=conversation-XucG_K3l.js.map