agents 0.28.1 → 0.29.0

package/dist/chat/index.js

@@ -1,4 +1,6 @@
 import { isPositionlessAgentToolChunk } from "../agent-tool-types.js";
+import { i as _classPrivateFieldInitSpec, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../classPrivateFieldGet2-DZBYAB34.js";
+import { t as _classPrivateMethodInitSpec } from "../classPrivateMethodInitSpec-qMjJ6sHQ.js";
 import { isDurableObjectResetError, isPlatformFailure, tryN } from "../retries.js";
 import { a as isReplayChunk, i as isLateToolInputChunk, n as applyLateToolInput, o as lateToolInputForwardChunks, r as getPartialStreamText, s as normalizeToolInput, t as applyChunkToParts } from "../message-builder-DAl9AhHH.js";
 import { a as interceptAgentToolBroadcast, i as createAgentToolEventState, r as applyAgentToolEvent, s as storedChunkBytes, t as AgentToolProgressEmitter } from "../agent-tools-CdJC-8Dc.js";
@@ -3003,18 +3005,14 @@ const DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS = 10;
 */
 const DEFAULT_CHAT_RECOVERY_MAX_WORK = 1e4;
 /**
-* Tight, OOM-specific retry budget (#1825). A Durable Object memory-limit reset
-* (`isDurableObjectMemoryLimitReset`) is usually deterministic — the turn's
-* working set no longer fits in the isolate's 128 MB — so re-running it re-OOMs.
-* But a single OOM CAN be a transient spike (the isolate's 128 MB is shared
-* across the global scope / noisy neighbors), so recovery retries a small number
-* of times before sealing with `reason="out_of_memory"` rather than abandoning a
-* turn that one more attempt might have completed. Far tighter than the generic
-* `maxRecoveryWork` backstop because an OOM is attributable and re-running it is
-* expensive (it re-runs the model). Counts attempts that ended in an OOM, not
-* total attempts, so a turn interrupted by deploys (no OOM) is unaffected.
+* Default number of interrupted attempts a turn may accumulate before recovery
+* seals it with `reason="interrupted_attempts_exceeded"` (#2613). The original
+* turn counts, so a turn that dies every time runs the model at most five
+* times. A deterministic memory-limit reset dies every time; a deploy rarely
+* lands on the same turn five times in a row, so five tolerates churn while
+* still bounding a crash loop.
 */
-const DEFAULT_CHAT_RECOVERY_MAX_OOM_RETRIES = 3;
+const DEFAULT_CHAT_RECOVERY_MAX_INTERRUPTED_ATTEMPTS = 5;
 const DEFAULT_CHAT_RECOVERY_STABLE_TIMEOUT_MS = 1e4;
 /**
 * Delay before retrying a recovery that timed out waiting for stable state.
@@ -3061,12 +3059,25 @@ function resolveChatRecoveryConfig(raw) {
 		terminalMessage: custom?.terminalMessage ?? "The assistant was interrupted and could not recover. Please try again.",
 		noProgressTimeoutMs: Math.max(0, Math.floor(custom?.noProgressTimeoutMs ?? 3e5)),
 		maxRecoveryWork: typeof custom?.maxRecoveryWork === "number" && custom.maxRecoveryWork >= 0 ? custom.maxRecoveryWork : DEFAULT_CHAT_RECOVERY_MAX_WORK,
-		maxOomRetries: typeof custom?.maxOomRetries === "number" && custom.maxOomRetries >= 0 ? Math.floor(custom.maxOomRetries) : 3,
+		maxInterruptedAttempts: resolveMaxInterruptedAttempts(custom),
 		...custom?.shouldKeepRecovering ? { shouldKeepRecovering: custom.shouldKeepRecovering } : {},
 		...custom?.onExhausted ? { onExhausted: custom.onExhausted } : {}
 	};
 }
 /**
+* Read the interruption budget, honoring the deprecated `maxOomRetries` alias
+* as `maxOomRetries + 1` so an explicit retry count keeps its meaning. A
+* negative or non-numeric value falls back to the default; `Infinity` is kept
+* and disables the bound.
+*/
+function resolveMaxInterruptedAttempts(custom) {
+	const attempts = custom?.maxInterruptedAttempts;
+	if (typeof attempts === "number" && attempts >= 0) return Math.max(1, Math.floor(attempts));
+	const legacyRetries = custom?.maxOomRetries;
+	if (typeof legacyRetries === "number" && legacyRetries >= 0) return Math.floor(legacyRetries) + 1;
+	return 5;
+}
+/**
 * Stable identifier for a recovery incident.
 *
 * `recoveryKind` is intentionally NOT part of the identity: a single
@@ -3293,6 +3304,10 @@ async function setChatRecovering(active, requestId, deps) {
 *    no-progress alarm loop.
 *  - RUNAWAY — the work budget seals a loop that keeps emitting content but
 *    never converges. Keyed to WORK done, not wall-clock. Defaults to no cap.
+*  - CRASH-LOOP — the interruption budget counts attempts whose isolate died
+*    before they finished, and never resets on progress. The death is
+*    counted by whoever starts the next attempt, because the isolate that
+*    died cannot record anything (#2613).
 *  - CALLER — `shouldKeepRecovering` lets the integrator express a
 *    token/cost/step budget the SDK should not hardcode. Consulted only when no
 *    hard bound has already sealed the incident, and never on first detection.
@@ -3301,7 +3316,7 @@ async function setChatRecovering(active, requestId, deps) {
 * suppressed and the no-progress clock kept fresh.
 */
 async function evaluateChatRecoveryIncident(input) {
-	const { identity, config, existing, currentProgress, awaitingClientInteraction, now } = input;
+	const { identity, trigger, config, existing, currentProgress, awaitingClientInteraction, now } = input;
 	const incidentId = chatRecoveryIncidentId(identity);
 	const recoveryRootRequestId = identity.recoveryRootRequestId ?? identity.requestId;
 	const prevProgress = existing?.progress ?? 0;
@@ -3312,14 +3327,15 @@ async function evaluateChatRecoveryIncident(input) {
 	const progress = Math.max(prevProgress, currentProgress);
 	const work = progress - workBaseline;
 	const workBudgetExceeded = existing != null && Number.isFinite(config.maxRecoveryWork) && work > config.maxRecoveryWork;
-	const oomAttempts = existing?.oomAttempts ?? 0;
-	const oomBudgetExceeded = existing != null && !awaitingClientInteraction && oomAttempts > config.maxOomRetries;
+	const newlyInterrupted = trigger.kind !== "interrupted" ? 0 : existing == null ? 1 : deadIsolateCount(existing.attemptsInFlight, trigger.attempt);
+	const interruptedAttempts = (existing?.interruptedAttempts ?? 0) + newlyInterrupted;
+	const interruptedBudgetExceeded = !awaitingClientInteraction && interruptedAttempts >= config.maxInterruptedAttempts;
 	const transientRetries = existing?.transientRetries ?? 0;
 	const transientBudgetExceeded = existing != null && !awaitingClientInteraction && transientRetries >= config.maxAttempts;
 	const debounced = existing != null && !madeProgress && now - existing.lastAttemptAt < 3e4;
 	const attempt = madeProgress ? 1 : debounced ? existing?.attempt ?? 1 : (existing?.attempt ?? 0) + 1;
 	let abortedByCaller = false;
-	if (existing != null && !awaitingClientInteraction && config.shouldKeepRecovering && !noProgressExceeded && !workBudgetExceeded && !oomBudgetExceeded && !transientBudgetExceeded && attempt <= config.maxAttempts) try {
+	if (existing != null && !awaitingClientInteraction && config.shouldKeepRecovering && !noProgressExceeded && !workBudgetExceeded && !interruptedBudgetExceeded && !transientBudgetExceeded && attempt <= config.maxAttempts) try {
 		const ctx = {
 			incidentId,
 			requestId: identity.requestId,
@@ -3334,7 +3350,7 @@ async function evaluateChatRecoveryIncident(input) {
 	} catch (error) {
 		input.onShouldKeepRecoveringError?.(error);
 	}
-	const exhausted = !awaitingClientInteraction && (oomBudgetExceeded || noProgressExceeded || workBudgetExceeded || abortedByCaller || transientBudgetExceeded || attempt > config.maxAttempts);
+	const exhausted = !awaitingClientInteraction && (interruptedBudgetExceeded || noProgressExceeded || workBudgetExceeded || abortedByCaller || transientBudgetExceeded || attempt > config.maxAttempts);
 	const incident = {
 		incidentId,
 		requestId: identity.requestId,
@@ -3348,9 +3364,10 @@ async function evaluateChatRecoveryIncident(input) {
 		lastProgressAt,
 		progress,
 		workBaseline,
-		...oomAttempts > 0 ? { oomAttempts } : {},
+		...interruptedAttempts > 0 ? { interruptedAttempts } : {},
+		...attemptsInFlightAfter(trigger, existing, exhausted),
 		...transientRetries > 0 ? { transientRetries } : {},
-		...exhausted ? { reason: oomBudgetExceeded ? "out_of_memory" : workBudgetExceeded ? "work_budget_exceeded" : noProgressExceeded ? "no_progress_timeout" : abortedByCaller ? "recovery_aborted" : "max_attempts_exceeded" } : {}
+		...exhausted ? { reason: interruptedBudgetExceeded ? "interrupted_attempts_exceeded" : workBudgetExceeded ? "work_budget_exceeded" : noProgressExceeded ? "no_progress_timeout" : abortedByCaller ? "recovery_aborted" : "max_attempts_exceeded" } : {}
 	};
 	const events = [];
 	if (!existing) events.push({
@@ -3375,8 +3392,87 @@ async function evaluateChatRecoveryIncident(input) {
 		events
 	};
 }
+/**
+* How many other isolates left attempts in `recorded`. Each such isolate died
+* mid-attempt once, however many attempts it was running.
+*/
+function deadIsolateCount(recorded, current) {
+	const dead = /* @__PURE__ */ new Set();
+	for (const attempt of recorded ?? []) if (attempt.isolate !== current.isolate) dead.add(attempt.isolate);
+	return dead.size;
+}
+/** The attempts in `recorded` that are still running in `current`'s isolate. */
+function liveAttempts(recorded, current) {
+	return (recorded ?? []).filter((attempt) => attempt.isolate === current.isolate);
+}
+/** Persist `attempts` only when there is at least one. */
+function withAttemptsInFlight(attempts) {
+	return attempts.length > 0 ? { attemptsInFlight: attempts } : {};
+}
+/**
+* The `attemptsInFlight` an incident opening leaves behind. A replay drops
+* the dead isolates' entries it just counted and adds itself, unless the
+* incident is now sealed; a stall leaves the running attempts untouched.
+*/
+function attemptsInFlightAfter(trigger, existing, exhausted) {
+	if (trigger.kind === "interrupted") {
+		const live = liveAttempts(existing?.attemptsInFlight, trigger.attempt);
+		return withAttemptsInFlight(exhausted ? live : [...live, trigger.attempt]);
+	}
+	return withAttemptsInFlight([...existing?.attemptsInFlight ?? []]);
+}
+/**
+* Admit one recovery attempt (a `_chatRecoveryContinue` / `_chatRecoveryRetry`
+* callback and the turn it starts) before it does any heavy work (#2613).
+*
+* Entries in `attemptsInFlight` left by other isolates are attempts that
+* died, for example to a memory-limit reset before or during their turn.
+* Each such isolate counts as one interrupted attempt and its entries are
+* dropped. The returned incident adds `attempt` to the running attempts,
+* unless the budget is spent, in which case the caller seals the incident
+* instead of running anything. A parked turn is budget-free: it is counted
+* but never sealed.
+*
+* @param input - The incident, the attempt about to start, and the budget.
+* @returns The incident to persist, and whether the budget is spent.
+*/
+function admitChatRecoveryAttempt(input) {
+	const { existing, attempt, config, awaitingClientInteraction } = input;
+	const interruptedAttempts = (existing.interruptedAttempts ?? 0) + deadIsolateCount(existing.attemptsInFlight, attempt);
+	const exhausted = !awaitingClientInteraction && interruptedAttempts >= config.maxInterruptedAttempts;
+	const live = liveAttempts(existing.attemptsInFlight, attempt);
+	const { attemptsInFlight: _previous, ...rest } = existing;
+	return {
+		incident: {
+			...rest,
+			...interruptedAttempts > 0 ? { interruptedAttempts } : {},
+			...withAttemptsInFlight(exhausted ? live : [...live, attempt])
+		},
+		exhausted
+	};
+}
+/**
+* Remove `attempt` from the running attempts once it finished in this
+* isolate. Other running attempts stay recorded.
+*
+* @param existing - The persisted incident.
+* @param attempt - The attempt that finished.
+* @returns The incident to persist, or `null` when `attempt` is not recorded.
+*/
+function finishChatRecoveryAttempt(existing, attempt) {
+	const recorded = existing.attemptsInFlight ?? [];
+	const remaining = recorded.filter((entry) => entry.token !== attempt.token);
+	if (remaining.length === recorded.length) return null;
+	const { attemptsInFlight: _finished, ...rest } = existing;
+	return {
+		...rest,
+		...withAttemptsInFlight(remaining)
+	};
+}
 //#endregion
 //#region src/chat/recovery-engine.ts
+var _isolate = /* @__PURE__ */ new WeakMap();
+var _ChatRecoveryEngine_brand = /* @__PURE__ */ new WeakSet();
 /**
 * Drives the shared recovery orchestration over a {@link ChatRecoveryAdapter}.
 * The incident *budget math* lives in the pure `evaluateChatRecoveryIncident`;
@@ -3385,6 +3481,59 @@ async function evaluateChatRecoveryIncident(input) {
 var ChatRecoveryEngine = class {
 	constructor(adapter) {
 		this.adapter = adapter;
+		_classPrivateMethodInitSpec(this, _ChatRecoveryEngine_brand);
+		_classPrivateFieldInitSpec(this, _isolate, crypto.randomUUID());
+	}
+	/**
+	* Run one recovery attempt under the interruption budget (#2613): a
+	* `_chatRecoveryContinue` / `_chatRecoveryRetry` callback and the turn it
+	* starts. Before `run` does anything heavy, the attempt counts any earlier
+	* attempt that died (entries another isolate left in `attemptsInFlight`)
+	* and records itself, confirmed with `syncStorage`. Once
+	* `maxInterruptedAttempts` attempts have died the turn is sealed with
+	* `interrupted_attempts_exceeded` and `run` is never called. The entry is
+	* removed when `run` settles, whatever its outcome.
+	*
+	* This catches deaths the replay of an interrupted turn run cannot see, such
+	* as a reset before the callback starts its turn, which leaves no turn run
+	* to replay. A callback for a sealed incident does nothing: the turn was
+	* already terminalized, and running it would re-run the model. A payload
+	* without an incident, or one whose incident is gone, runs untracked.
+	*
+	* @param input - The callback being run, its payload, and the work.
+	*/
+	async runRecoveryAttempt(input) {
+		const { adapter } = this;
+		const incidentId = typeof input.data?.incidentId === "string" ? input.data.incidentId : void 0;
+		const existing = incidentId ? await adapter.getIncident(chatRecoveryIncidentKey(incidentId)) : null;
+		if (existing?.status === "exhausted") return;
+		if (!incidentId || !existing) {
+			await input.run();
+			return;
+		}
+		adapter.ensureInteractionStateLoaded?.();
+		const attempt = _assertClassBrand(_ChatRecoveryEngine_brand, this, _newAttempt).call(this);
+		const { incident, exhausted } = admitChatRecoveryAttempt({
+			existing,
+			attempt,
+			config: adapter.resolveConfig(),
+			awaitingClientInteraction: adapter.isAwaitingClientInteraction?.() ?? false
+		});
+		await adapter.putIncident(chatRecoveryIncidentKey(incidentId), incident);
+		await adapter.syncStorage();
+		if (exhausted) {
+			await this.exhaustRecoveryGiveUp({
+				callback: input.callback,
+				data: { incidentId },
+				reason: "interrupted_attempts_exceeded"
+			});
+			return;
+		}
+		try {
+			await input.run();
+		} finally {
+			await _assertClassBrand(_ChatRecoveryEngine_brand, this, _finishAttempt).call(this, incidentId, attempt);
+		}
 	}
 	/**
 	* Open or re-evaluate the recovery incident for `input`, persist the result,
@@ -3447,61 +3596,32 @@ var ChatRecoveryEngine = class {
 			streamStatus
 		});
 		const recoveryRootRequestId = snapshot?.recoveryRootRequestId ?? requestId;
-		const { incident, config, exhausted } = await this.beginIncident({
+		const { incident, config, exhausted, attempt } = await this.beginIncident({
 			requestId,
 			recoveryRootRequestId,
 			latestUserMessageId: snapshot?.latestUserMessageId,
-			recoveryKind
+			recoveryKind,
+			trigger: "interrupted"
 		});
-		if (exhausted) {
-			if (await this._shouldPersistOrphanedPartial(wake, {
-				streamId,
-				streamStillActive,
-				streamStatus,
-				snapshot,
-				options: void 0,
-				partial
-			})) await wake.persistOrphanedStream(streamId);
-			await adapter.exhaustChatRecovery(incident, config, partial, streamId, ctx.createdAt, snapshot?.originMessageIds);
-			return true;
-		}
 		try {
-			const options = await wake.invokeOnChatRecovery?.({
+			return await _assertClassBrand(_ChatRecoveryEngine_brand, this, _replayRecoveredTurn).call(this, wake, {
+				ctx,
 				incident,
+				config,
+				exhausted,
 				recoveryKind,
-				recoveryRootRequestId,
+				detail,
 				requestId,
-				streamId,
-				partial,
+				recoveryRootRequestId,
 				snapshot,
 				recoveryData,
-				createdAt: ctx.createdAt
-			}) ?? {};
-			if (await this._shouldPersistOrphanedPartial(wake, {
 				streamId,
 				streamStillActive,
 				streamStatus,
-				snapshot,
-				options,
 				partial
-			})) await wake.persistOrphanedStream(streamId);
-			if (streamStillActive) await wake.completeRecoveredStream(streamId);
-			await wake.dispatchRecoveredTurn({
-				incident,
-				config,
-				recoveryKind,
-				options,
-				snapshot,
-				requestId,
-				recoveryRootRequestId,
-				streamId,
-				streamStatus,
-				detail
 			});
-			return true;
-		} catch (error) {
-			await this.updateIncident(incident.incidentId, "failed", error instanceof Error ? error.message : String(error));
-			throw error;
+		} finally {
+			if (attempt) await _assertClassBrand(_ChatRecoveryEngine_brand, this, _finishAttempt).call(this, incident.incidentId, attempt);
 		}
 	}
 	/**
@@ -3530,21 +3650,29 @@ var ChatRecoveryEngine = class {
 		await adapter.sweepStaleIncidents(now);
 		const existing = await adapter.getIncident(key);
 		adapter.ensureInteractionStateLoaded?.();
+		const currentProgress = await adapter.readProgress();
+		const trigger = input.trigger === "interrupted" ? {
+			kind: "interrupted",
+			attempt: _assertClassBrand(_ChatRecoveryEngine_brand, this, _newAttempt).call(this)
+		} : { kind: "stalled" };
 		const { incident, exhausted, events } = await evaluateChatRecoveryIncident({
 			identity: input,
+			trigger,
 			config,
 			existing,
-			currentProgress: await adapter.readProgress(),
+			currentProgress,
 			awaitingClientInteraction: adapter.isAwaitingClientInteraction?.() ?? false,
 			now,
 			onShouldKeepRecoveringError: (error) => adapter.onShouldKeepRecoveringError?.(error)
 		});
 		await adapter.putIncident(key, incident);
+		await adapter.syncStorage();
 		for (const event of events) adapter.emitRecoveryEvent(event);
 		return {
 			incident,
 			config,
-			exhausted
+			exhausted,
+			attempt: trigger.kind === "interrupted" && !exhausted ? trigger.attempt : null
 		};
 	}
 	/**
@@ -3656,54 +3784,6 @@ var ChatRecoveryEngine = class {
 		return incident?.status === "skipped" && incident.reason === "user_cancelled";
 	}
 	/**
-	* Record that a recovery callback observed a Durable Object memory-limit reset
-	* (the isolate exceeded its 128 MB limit — `isDurableObjectMemoryLimitReset`)
-	* and decide what to do next (#1825).
-	*
-	* Bumps the incident's durable `oomAttempts` counter, then:
-	*  - if it is still within `maxOomRetries`, issues a delayed, NON-idempotent
-	*    reschedule of the SAME callback (same machinery as
-	*    {@link rescheduleAfterStableTimeout}: the executing attempt settles
-	*    only after the callback returns, so an idempotent reschedule would
-	*    dedup onto that doomed attempt) and returns `"rescheduled"`. The small
-	*    delay lets a transient memory spike clear before the re-run;
-	*  - otherwise leaves the incremented count persisted (so a begin-path
-	*    re-evaluation agrees) and returns `"exhausted"` — the caller then
-	*    terminalizes via the give-up path with `reason="out_of_memory"`.
-	*
-	* Returns `"exhausted"` when there is no incident to track against (no id /
-	* record gone): an OOM we cannot bound must seal rather than loop. Unlike a
-	* stable-state retry this is gated by the OOM-specific budget, NOT the generic
-	* attempt cap — re-running an OOM streams a little "progress" that would
-	* otherwise reset the attempt cap forever (the #1825 loop).
-	*/
-	async recordOomAndDecide(input) {
-		const { adapter } = this;
-		if (!input.incidentId) return "exhausted";
-		const key = chatRecoveryIncidentKey(input.incidentId);
-		const incident = await adapter.getIncident(key);
-		if (!incident) return "exhausted";
-		const oomAttempts = (incident.oomAttempts ?? 0) + 1;
-		if (oomAttempts > input.maxOomRetries) {
-			await adapter.putIncident(key, {
-				...incident,
-				oomAttempts,
-				lastAttemptAt: adapter.now(),
-				reason: "out_of_memory"
-			});
-			return "exhausted";
-		}
-		await adapter.putIncident(key, {
-			...incident,
-			oomAttempts,
-			status: "scheduled",
-			lastAttemptAt: adapter.now(),
-			reason: "oom_retry"
-		});
-		await adapter.scheduleRecovery(input.callback, input.data ?? {}, "stable_timeout_retry", 3);
-		return "rescheduled";
-	}
-	/**
 	* Give up on a recovery turn whose retry budget drained, terminalizing it so
 	* it can never become an eternal spinner (#1645). The shared spine both
 	* packages repeated verbatim:
@@ -3822,6 +3902,85 @@ var ChatRecoveryEngine = class {
 		else if (status === "completed" || status === "skipped" || status === "failed") await adapter.setRecovering(false);
 	}
 };
+function _newAttempt() {
+	return {
+		isolate: _classPrivateFieldGet2(_isolate, this),
+		token: crypto.randomUUID()
+	};
+}
+/**
+* Remove a finished attempt's entry and confirm the write, so a reset right
+* after a clean finish cannot make the attempt look interrupted.
+* Best-effort: in a reset isolate this fails too, and the entry it leaves
+* behind is exactly what tells the next isolate that this attempt died.
+*/
+async function _finishAttempt(incidentId, attempt) {
+	const { adapter } = this;
+	const key = chatRecoveryIncidentKey(incidentId);
+	try {
+		const stored = await adapter.getIncident(key);
+		const next = stored ? finishChatRecoveryAttempt(stored, attempt) : null;
+		if (next) {
+			await adapter.putIncident(key, next);
+			await adapter.syncStorage();
+		}
+	} catch {}
+}
+/** The part of {@link handleChatFiberRecovery} that runs after the incident opened. */
+async function _replayRecoveredTurn(wake, input) {
+	const { adapter } = this;
+	const { ctx, incident, config, exhausted, recoveryKind, detail, requestId, recoveryRootRequestId, snapshot, recoveryData, streamId, streamStillActive, streamStatus, partial } = input;
+	if (exhausted) {
+		if (await this._shouldPersistOrphanedPartial(wake, {
+			streamId,
+			streamStillActive,
+			streamStatus,
+			snapshot,
+			options: void 0,
+			partial
+		})) await wake.persistOrphanedStream(streamId);
+		await adapter.exhaustChatRecovery(incident, config, partial, streamId, ctx.createdAt, snapshot?.originMessageIds);
+		return true;
+	}
+	try {
+		const options = await wake.invokeOnChatRecovery?.({
+			incident,
+			recoveryKind,
+			recoveryRootRequestId,
+			requestId,
+			streamId,
+			partial,
+			snapshot,
+			recoveryData,
+			createdAt: ctx.createdAt
+		}) ?? {};
+		if (await this._shouldPersistOrphanedPartial(wake, {
+			streamId,
+			streamStillActive,
+			streamStatus,
+			snapshot,
+			options,
+			partial
+		})) await wake.persistOrphanedStream(streamId);
+		if (streamStillActive) await wake.completeRecoveredStream(streamId);
+		await wake.dispatchRecoveredTurn({
+			incident,
+			config,
+			recoveryKind,
+			options,
+			snapshot,
+			requestId,
+			recoveryRootRequestId,
+			streamId,
+			streamStatus,
+			detail
+		});
+		return true;
+	} catch (error) {
+		await this.updateIncident(incident.incidentId, "failed", error instanceof Error ? error.message : String(error));
+		throw error;
+	}
+}
 /** `incident.reason` for a scheduled recovery the user cancelled. */
 const CHAT_RECOVERY_CANCELLED_REASON = "user_cancelled";
 /**
@@ -4159,6 +4318,6 @@ function isProviderExecuted(part) {
 	return part.providerExecuted === true;
 }
 //#endregion
-export { AGENT_TOOL_STREAM_PROGRESS_BUMP_THROTTLE_MS, AbortRegistry, AgentToolProgressEmitter, AgentToolStreamProgressThrottle, AutoContinuationController, CHAT_LAST_TERMINAL_KEY, CHAT_MESSAGE_TYPES, CHAT_RECOVERING_FLAG_TTL_MS, CHAT_RECOVERING_KEY, CHAT_RECOVERY_ALARM_DEBOUNCE_MS, CHAT_RECOVERY_CANCELLED_REASON, CHAT_RECOVERY_INCIDENT_KEY_PREFIX, CHAT_RECOVERY_INCIDENT_TTL_MS, CHAT_RECOVERY_PROGRESS_KEY, CHAT_RECOVERY_STABLE_RETRY_DELAY_SECONDS, CHAT_RECOVERY_TASK_NAME, CHAT_STREAM_PROGRESS_CREDIT_THROTTLE_MS, ChatRecoveryEngine, ChatStreamStalledError, ContinuationState, DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS, DEFAULT_CHAT_RECOVERY_MAX_OOM_RETRIES, DEFAULT_CHAT_RECOVERY_MAX_WORK, DEFAULT_CHAT_RECOVERY_NO_PROGRESS_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_STABLE_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_TERMINAL_MESSAGE, KV_DELETE_MAX_KEYS, MAX_BOUND_PARAMS, MessageType, PreStreamTurns, ROW_MAX_BYTES, ResumableStream, ResumeHandshake, STREAM_RESUME_NONE_REASONS, StreamAccumulator, StreamProgressCreditThrottle, SubmitConcurrencyController, TIMED_OUT, TextSegmentJoiner, TurnQueue, aiSdkRecoveryCodec, applyAgentToolEvent, applyChunkToParts, applyLateToolInput, applyToolUpdate, awaitWithDeadline, transition as broadcastTransition, buildChatRecoveringFrame, buildInClauseStrings, bumpChatRecoveryProgress, byteLength, chatRecoveryBackoffSeconds, chatRecoveryTaskRunOptions, classifyAgentToolChildRecovery, clearChatTerminal, clientResolvableToolNames, createAgentToolEventState, createChatFiberSnapshot, createChatRecoveryTaskDefinition, createChatStreams, createChatTurnTaskDefinition, createToolsFromClientSchemas, crossMessageToolResultUpdate, dispatchChatRecoveryToHandoff, drainInteractionApplies, enforceRowSizeLimit, hasIncompleteToolBatch, interceptAgentToolBroadcast, isDurableObjectResetError, isLateToolInputChunk, isPlatformFailure, isPositionlessAgentToolChunk, isReplayChunk, iterateWithStallWatchdog, lateToolInputForwardChunks, listActiveChatRecoveryIncidents, normalizeToolInput, originMessageIds, parseProtocolMessage, partAwaitsClientInteraction, partialHasSettledToolResults, pausedExecutionUpdate, pendingChatTerminal, persistReconstructedOrphan, readChatRecoveryProgress, reconcileMessages, reconcileOrphanPartial, recordChatTerminal, repairInterruptedToolParts, resolveChatRecoveryConfig, resolveToolMergeId, retryAfterSeconds, runChatRecoveryExhaustion, sanitizeMessage, sendIfOpen, setChatRecovering, shouldCreditStreamProgress, sweepStaleChatRecoveryIncidents, toolApprovalUpdate, toolPartHasSettledResult, toolResultUpdate, truncateOlderMessages, truncateOlderToolResults, unwrapChatFiberSnapshot, withOriginMessageIds, wrapChatFiberSnapshot };
+export { AGENT_TOOL_STREAM_PROGRESS_BUMP_THROTTLE_MS, AbortRegistry, AgentToolProgressEmitter, AgentToolStreamProgressThrottle, AutoContinuationController, CHAT_LAST_TERMINAL_KEY, CHAT_MESSAGE_TYPES, CHAT_RECOVERING_FLAG_TTL_MS, CHAT_RECOVERING_KEY, CHAT_RECOVERY_ALARM_DEBOUNCE_MS, CHAT_RECOVERY_CANCELLED_REASON, CHAT_RECOVERY_INCIDENT_KEY_PREFIX, CHAT_RECOVERY_INCIDENT_TTL_MS, CHAT_RECOVERY_PROGRESS_KEY, CHAT_RECOVERY_STABLE_RETRY_DELAY_SECONDS, CHAT_RECOVERY_TASK_NAME, CHAT_STREAM_PROGRESS_CREDIT_THROTTLE_MS, ChatRecoveryEngine, ChatStreamStalledError, ContinuationState, DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS, DEFAULT_CHAT_RECOVERY_MAX_INTERRUPTED_ATTEMPTS, DEFAULT_CHAT_RECOVERY_MAX_WORK, DEFAULT_CHAT_RECOVERY_NO_PROGRESS_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_STABLE_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_TERMINAL_MESSAGE, KV_DELETE_MAX_KEYS, MAX_BOUND_PARAMS, MessageType, PreStreamTurns, ROW_MAX_BYTES, ResumableStream, ResumeHandshake, STREAM_RESUME_NONE_REASONS, StreamAccumulator, StreamProgressCreditThrottle, SubmitConcurrencyController, TIMED_OUT, TextSegmentJoiner, TurnQueue, aiSdkRecoveryCodec, applyAgentToolEvent, applyChunkToParts, applyLateToolInput, applyToolUpdate, awaitWithDeadline, transition as broadcastTransition, buildChatRecoveringFrame, buildInClauseStrings, bumpChatRecoveryProgress, byteLength, chatRecoveryBackoffSeconds, chatRecoveryTaskRunOptions, classifyAgentToolChildRecovery, clearChatTerminal, clientResolvableToolNames, createAgentToolEventState, createChatFiberSnapshot, createChatRecoveryTaskDefinition, createChatStreams, createChatTurnTaskDefinition, createToolsFromClientSchemas, crossMessageToolResultUpdate, dispatchChatRecoveryToHandoff, drainInteractionApplies, enforceRowSizeLimit, hasIncompleteToolBatch, interceptAgentToolBroadcast, isDurableObjectResetError, isLateToolInputChunk, isPlatformFailure, isPositionlessAgentToolChunk, isReplayChunk, iterateWithStallWatchdog, lateToolInputForwardChunks, listActiveChatRecoveryIncidents, normalizeToolInput, originMessageIds, parseProtocolMessage, partAwaitsClientInteraction, partialHasSettledToolResults, pausedExecutionUpdate, pendingChatTerminal, persistReconstructedOrphan, readChatRecoveryProgress, reconcileMessages, reconcileOrphanPartial, recordChatTerminal, repairInterruptedToolParts, resolveChatRecoveryConfig, resolveToolMergeId, retryAfterSeconds, runChatRecoveryExhaustion, sanitizeMessage, sendIfOpen, setChatRecovering, shouldCreditStreamProgress, sweepStaleChatRecoveryIncidents, toolApprovalUpdate, toolPartHasSettledResult, toolResultUpdate, truncateOlderMessages, truncateOlderToolResults, unwrapChatFiberSnapshot, withOriginMessageIds, wrapChatFiberSnapshot };
 
 //# sourceMappingURL=index.js.map