agents 0.15.0 → 0.16.0

package/dist/experimental/memory/utils/index.d.ts

@@ -1,5 +1,5 @@
 import {
-  M as SessionMessage,
+  P as SessionMessage,
   a as alignBoundaryBackward,
   c as computeSummaryBudget,
   d as isCompactionMessage,
@@ -12,7 +12,7 @@ import {
   s as buildSummaryPrompt,
   t as COMPACTION_PREFIX,
   u as findTailCutByTokens
-} from "../../../compaction-helpers-BEUILPss.js";
+} from "../../../compaction-helpers-DVcu5lPN.js";
 
 //#region src/experimental/memory/utils/tokens.d.ts
 /** Approximate characters per token for English text */

package/dist/{index-CPe1OtI0.d.ts → index-B7IbEeze.d.ts}

@@ -408,6 +408,37 @@ type AgentObservabilityEvent =
         toolCallIds?: string[];
       }
     >
+  | BaseEvent<
+      "chat:onstart:degraded",
+      {
+        /**
+         * Internal onStart step that failed and was skipped so the agent
+         * could still come up instead of bricking the DO (#1710).
+         */
+        step:
+          | "transcript-hydration"
+          | "scheduled-task-reconcile"
+          | "durable-work-recovery";
+        error: string;
+      }
+    >
+  | BaseEvent<
+      "chat:hydration:windowed",
+      {
+        /** Stored size of the full active path, in bytes. */ totalContentBytes: number /** The configured `hydrationByteBudget`. */;
+        budgetBytes: number /** Number of recent messages hydrated into the in-memory window. */;
+        hydratedMessages: number;
+      }
+    >
+  | BaseEvent<
+      "chat:media:evicted",
+      {
+        /** Stored messages rewritten during this eviction pass. */ messages: number /** Individual oversized parts evicted across those messages. */;
+        parts: number /** Total bytes removed from the stored transcript. */;
+        bytes: number /** Bytes preserved as workspace files (≤ `bytes`). */;
+        externalizedBytes: number;
+      }
+    >
   | BaseEvent<
       "chat:stream:stalled",
       {
@@ -730,4 +761,4 @@ export {
   MCPObservabilityEvent as s,
   ChannelEventMap as t
 };
-//# sourceMappingURL=index-CPe1OtI0.d.ts.map
+//# sourceMappingURL=index-B7IbEeze.d.ts.map

package/dist/index.d.ts

@@ -71,9 +71,13 @@ import {
   xt as normalizeServerId,
   y as AddRpcMcpServerOptions,
   z as MCPServer
-} from "./agent-tool-types-VPsjVYL0.js";
+} from "./agent-tool-types-NofdbL9X.js";
 import { n as camelCaseToKebabCase } from "./utils-CGtGDSgA.js";
-import { t as RetryOptions } from "./retries-CF_HKSlJ.js";
+import {
+  i as isPlatformTransientError,
+  n as isDurableObjectCodeUpdateReset,
+  t as RetryOptions
+} from "./retries-CwlpAGet.js";
 import {
   n as AgentsOAuthProvider,
   r as DurableObjectOAuthClientProvider,
@@ -154,6 +158,8 @@ export {
   getAgentByName,
   getCurrentAgent,
   getSubAgentByName,
+  isDurableObjectCodeUpdateReset,
+  isPlatformTransientError,
   normalizeServerId,
   parseSubAgentPath,
   routeAgentEmail,

package/dist/index.js

@@ -2,9 +2,9 @@ import { __DO_NOT_USE_WILL_BREAK__agentContext } from "./internal_context.js";
 import { MessageType } from "./types.js";
 import { camelCaseToKebabCase, isInternalJsStubProp } from "./utils.js";
 import { createHeaderBasedEmailResolver, signAgentHeaders } from "./email.js";
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-Beqsfu2Z.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-CZ7QjTXN.js";
 import { SUB_PREFIX, getSubAgentByName, parseSubAgentPath, routeSubAgentRequest } from "./sub-routing.js";
-import { isErrorRetryable, tryN, validateRetryOptions } from "./retries.js";
+import { isDurableObjectCodeUpdateReset, isErrorRetryable, isPlatformTransientError, tryN, validateRetryOptions } from "./retries.js";
 import { a as MCPConnectionState, c as RPC_DO_PREFIX, i as normalizeServerId, l as DisposableStore, n as MCP_SERVER_ID_MAX_LENGTH, t as MCPClientManager } from "./client-FUizKzj2.js";
 import { DurableObjectOAuthClientProvider } from "./mcp/do-oauth-client-provider.js";
 import { genericObservability } from "./observability/index.js";
@@ -16,6 +16,18 @@ import { RpcTarget, exports } from "cloudflare:workers";
 import { Server, getServerByName, routePartykitRequest } from "partyserver";
 //#region src/index.ts
 let _Symbol$dispose;
+function isClosedWebSocketSendError(error) {
+	return error instanceof TypeError && error.message.includes("WebSocket send() after close");
+}
+function sendRpcResponseIfOpen(connection, response) {
+	try {
+		connection.send(JSON.stringify(response));
+		return true;
+	} catch (error) {
+		if (isClosedWebSocketSendError(error)) return false;
+		throw error;
+	}
+}
 /**
 * Type guard for RPC request messages
 */
@@ -116,6 +128,10 @@ function getNextCronTime(cron) {
 const DEFAULT_KEEP_ALIVE_INTERVAL_MS = 3e4;
 const DEFAULT_AGENT_TOOL_RECOVERY_TIMEOUT_MS = 2e3;
 const DEFAULT_AGENT_TOOL_RECOVERY_TOTAL_TIMEOUT_MS = 5e3;
+const DESTROY_PENDING_KEY = "cf_agents_destroy_pending";
+const DESTROY_ALARM_DELAY_MS = 1e3;
+const FIBER_RECOVERY_MAX_BACKOFF_MS = 5 * 6e4;
+const FIBER_RECOVERY_BACKOFF_MAX_EXP = 20;
 const DEFAULT_AGENT_TOOL_REATTACH_NO_PROGRESS_TIMEOUT_MS = 12e4;
 const DEFAULT_AGENT_TOOL_REATTACH_MAX_WINDOW_MS = Number.POSITIVE_INFINITY;
 const SUB_AGENT_IDENTITY_VERSION_LEGACY = "legacy";
@@ -319,36 +335,6 @@ function resolveRetryConfig(taskRetry, defaults) {
 		maxDelayMs: taskRetry?.maxDelayMs ?? defaults.maxDelayMs
 	};
 }
-/**
-* Whether an error is a transient "superseded isolate" failure — the invocation
-* is running on an isolate the platform has replaced with a new version (a
-* deploy / code update). For the rest of that invocation every operation throws
-* the same error (code never reloads mid-invocation), so in-process retries are
-* futile; but the next fresh invocation runs the new code and succeeds.
-*
-* workerd surfaces this as a plain `Error` with one of a few messages, all the
-* same failure class — a message match is the only signal:
-*   - "Durable Object reset because its code was updated."  (DO storage op on a
-*     superseded isolate / deploy bounce)
-*   - "This script has been upgraded. Please send a new request to connect to
-*     the new version."  (a stub/connection to a superseded script; the message
-*     literally instructs the caller to retry on the new version)
-*
-* The match stays close to the verbatim platform strings (rather than a loose
-* "upgraded"/"reset" substring) so an ordinary application error that happens
-* to mention those words is NOT misclassified as a supersede — a false positive
-* would defer + re-run a genuinely-failing callback on the platform's alarm
-* retries instead of abandoning it.
-*
-* NOTE: "Network connection lost." is deliberately NOT included — it is a
-* connection error, not an isolate replacement, and may succeed on in-process
-* retry (it is gated by the CF `retryable` property via `isErrorRetryable`),
-* so it stays on the normal retry path rather than the immediate-defer path.
-*/
-function isDurableObjectCodeUpdateReset(error) {
-	const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
-	return /reset because its code was updated|this script has been upgraded/i.test(message);
-}
 function getCurrentAgent() {
 	const store = __DO_NOT_USE_WILL_BREAK__agentContext.getStore();
 	if (!store) return {
@@ -720,6 +706,7 @@ var Agent = class Agent extends Server {
 		this._managedFiberExecutions = /* @__PURE__ */ new Map();
 		this._managedFiberTerminalWaiters = /* @__PURE__ */ new Map();
 		this._runFiberRecoveryInProgress = false;
+		this._recoveryNoProgressScans = 0;
 		this._ParentClass = Object.getPrototypeOf(this).constructor;
 		this.initialState = DEFAULT_STATE;
 		this.observability = genericObservability;
@@ -840,22 +827,20 @@ var Agent = class Agent extends Server {
 							method,
 							streaming: metadata?.streaming
 						});
-						const response = {
+						sendRpcResponseIfOpen(connection, {
 							done: true,
 							id,
 							result,
 							success: true,
 							type: "rpc"
-						};
-						connection.send(JSON.stringify(response));
+						});
 					} catch (e) {
-						const response = {
+						sendRpcResponseIfOpen(connection, {
 							error: e instanceof Error ? e.message : "Unknown error occurred",
 							id: parsed.id,
 							success: false,
 							type: "rpc"
-						};
-						connection.send(JSON.stringify(response));
+						});
 						console.error("RPC error:", e);
 						this._emit("rpc:error", {
 							method: parsed.method,
@@ -2324,6 +2309,9 @@ var Agent = class Agent extends Server {
 			if (disposed) return;
 			disposed = true;
 			this._keepAliveRefs = Math.max(0, this._keepAliveRefs - 1);
+			if (this._keepAliveRefs === 0) this.ctx.waitUntil(this._scheduleNextAlarm().catch((e) => {
+				console.error("[Agent] Failed to reschedule alarm after keepAlive dispose:", e);
+			}));
 		};
 	}
 	/**
@@ -2925,6 +2913,7 @@ var Agent = class Agent extends Server {
 		const scanStartedAt = Date.now();
 		const scanDeadlineMs = this._resolvedOptions.fiberRecoveryScanDeadlineMs;
 		const fiberRecoveryMaxAgeMs = this._resolvedOptions.fiberRecoveryMaxAgeMs;
+		let madeProgress = false;
 		try {
 			const rows = this.sql`SELECT id, name, snapshot, created_at FROM cf_agents_runs`;
 			for (const row of rows) {
@@ -2961,6 +2950,7 @@ var Agent = class Agent extends Server {
 				if (managedRow) {
 					if (this._isTerminalFiberStatus(managedRow.status)) {
 						this.sql`DELETE FROM cf_agents_runs WHERE id = ${row.id}`;
+						madeProgress = true;
 						this._notifyManagedFiberTerminal(row.id);
 						continue;
 					}
@@ -2987,6 +2977,7 @@ var Agent = class Agent extends Server {
 						elapsedMs: Date.now() - row.created_at
 					});
 					this.sql`DELETE FROM cf_agents_runs WHERE id = ${row.id}`;
+					madeProgress = true;
 				}
 				if (managedRow) this._notifyManagedFiberTerminal(row.id);
 			}
@@ -3042,10 +3033,13 @@ var Agent = class Agent extends Server {
 					elapsedMs: Date.now() - row.created_at
 				});
 				await this._runFiberRecoveryHook(ctx, row);
+				madeProgress = true;
 				this._notifyManagedFiberTerminal(row.fiber_id);
 			}
 		} finally {
 			this._runFiberRecoveryInProgress = false;
+			if (madeProgress) this._recoveryNoProgressScans = 0;
+			else this._recoveryNoProgressScans = this._hasPendingFiberRecovery() ? this._recoveryNoProgressScans + 1 : 0;
 		}
 	}
 	/** @internal */
@@ -3201,6 +3195,7 @@ var Agent = class Agent extends Server {
 			}
 			const isOneShotSchedule = row.type === "delayed" || row.type === "scheduled";
 			const shouldDeferReset = (error) => isOneShotSchedule && isDurableObjectCodeUpdateReset(error);
+			const shouldDeferOnExhaustion = (error) => isOneShotSchedule && isPlatformTransientError(error);
 			try {
 				this._emit("schedule:execute", {
 					callback: row.callback,
@@ -3224,6 +3219,10 @@ var Agent = class Agent extends Server {
 					console.warn(`Deferring scheduled callback "${row.callback}" to a fresh invocation after a Durable Object code-update reset; the one-shot row is preserved and the alarm will re-run on new code.`);
 					throw e;
 				}
+				if (shouldDeferOnExhaustion(e)) {
+					console.warn(`Deferring scheduled callback "${row.callback}" after exhausting in-process retries on a transient platform error; the one-shot row is preserved and the alarm will re-run once the platform recovers.`);
+					throw e;
+				}
 				console.error(`error executing callback "${row.callback}" after ${maxAttempts} attempts`, e);
 				this._emit("schedule:error", {
 					callback: row.callback,
@@ -3237,7 +3236,35 @@ var Agent = class Agent extends Server {
 			}
 		});
 	}
+	/**
+	* Whether any runFiber recovery work is still outstanding: orphaned
+	* `cf_agents_runs` rows left by a dead process (excluding fibers currently
+	* executing in memory, which already hold a keepAlive ref) or managed
+	* ledger fibers stuck in a non-terminal state with no live run row.
+	*
+	* Used by `_scheduleNextAlarm` to arm a follow-up alarm so multi-pass
+	* recovery (e.g. after a scan-deadline yield, or while retrying a throwing
+	* recovery hook) resumes instead of starving.
+	* @internal
+	*/
+	_hasPendingFiberRecovery() {
+		const runRows = this.sql`
+      SELECT id FROM cf_agents_runs
+    `;
+		for (const row of runRows) if (!this._runFiberActiveFibers.has(row.id)) return true;
+		return (this.sql`
+      SELECT COUNT(*) AS count
+      FROM cf_agents_fibers f
+      LEFT JOIN cf_agents_runs r ON r.id = f.fiber_id
+      WHERE f.status IN ('pending', 'running')
+        AND r.id IS NULL
+    `[0]?.count ?? 0) > 0;
+	}
 	async _scheduleNextAlarm() {
+		if (await this._hasPendingDestroy()) {
+			await this.ctx.storage.setAlarm(Date.now());
+			return;
+		}
 		const nowMs = Date.now();
 		const hungCutoffSeconds = Math.floor(nowMs / 1e3) - this._resolvedOptions.hungScheduleTimeoutSeconds;
 		const readySchedules = this.sql`
@@ -3266,6 +3293,12 @@ var Agent = class Agent extends Server {
 			const keepAliveMs = nowMs + this._resolvedOptions.keepAliveIntervalMs;
 			nextTimeMs = nextTimeMs === null ? keepAliveMs : Math.min(nextTimeMs, keepAliveMs);
 		}
+		if (this._hasPendingFiberRecovery()) {
+			const base = this._resolvedOptions.keepAliveIntervalMs;
+			const exp = Math.min(this._recoveryNoProgressScans, FIBER_RECOVERY_BACKOFF_MAX_EXP);
+			const recoveryMs = nowMs + Math.min(FIBER_RECOVERY_MAX_BACKOFF_MS, base * 2 ** exp);
+			nextTimeMs = nextTimeMs === null ? recoveryMs : Math.min(nextTimeMs, recoveryMs);
+		}
 		if ((this.sql`
       SELECT COUNT(*) as count FROM cf_agents_facet_runs
     `[0]?.count ?? 0) > 0) {
@@ -3297,6 +3330,10 @@ var Agent = class Agent extends Server {
 	* See {@link https://developers.cloudflare.com/agents/api-reference/schedule-tasks/}
 	*/
 	async alarm() {
+		if (await this._hasPendingDestroy()) {
+			await this.destroy();
+			return;
+		}
 		await super.alarm();
 		const now = Math.floor(Date.now() / 1e3);
 		const result = this.sql`
@@ -5167,6 +5204,7 @@ var Agent = class Agent extends Server {
 			await (await this._rootAlarmOwner())._cf_destroyDescendantFacet(this.selfPath);
 			return;
 		}
+		await this.ctx.storage.put(DESTROY_PENDING_KEY, true);
 		this._dropInternalTablesForDestroy();
 		await this.ctx.storage.deleteAlarm();
 		await this.ctx.storage.deleteAll();
@@ -5178,6 +5216,42 @@ var Agent = class Agent extends Server {
 		}, 0);
 		this._emit("destroy");
 	}
+	/**
+	* @internal Defer this agent's destruction to its own alarm invocation
+	* instead of running it inline (#1625).
+	*
+	* `destroy()` is a multi-step I/O sequence (drop tables, delete alarm,
+	* delete all storage, dispose connections). Running it on the `waitUntil`
+	* of a request whose client has already disconnected — the MCP
+	* Streamable-HTTP session-DELETE path — gives it little to no
+	* post-invocation grace, so the runtime routinely cancels it mid-flight.
+	* This method instead performs two fast storage writes (a durable
+	* "condemned" marker and an immediate alarm) that the caller can await
+	* before responding; the alarm then fires as a fresh invocation with its
+	* own full execution budget and runs `destroy()` there. If even that
+	* invocation is interrupted, the marker survives and the next wake
+	* finishes teardown — see the `alarm()` preamble.
+	*
+	* Unlike `destroy()`, this method does not abort the isolate, so RPC
+	* callers don't need to swallow an abort error.
+	*/
+	async _cf_scheduleDestroy() {
+		await this.__unsafe_ensureInitialized();
+		if (this._isFacet) {
+			await this.destroy();
+			return;
+		}
+		await this.ctx.storage.put(DESTROY_PENDING_KEY, true);
+		await this.ctx.storage.setAlarm(Date.now() + DESTROY_ALARM_DELAY_MS);
+	}
+	/**
+	* Whether a (deferred or interrupted) destroy is pending. Reads the
+	* durable marker directly — the in-memory `_isFacet` flag may not be
+	* hydrated yet at the call sites, but facets never write the marker.
+	*/
+	async _hasPendingDestroy() {
+		return await this.ctx.storage.get(DESTROY_PENDING_KEY) === true;
+	}
 	/** @internal Drop every internal Agents SDK table during top-level destroy. */
 	_dropInternalTablesForDestroy() {
 		this.sql`DROP TABLE IF EXISTS cf_agents_mcp_servers`;
@@ -6334,8 +6408,7 @@ var StreamingResponse = class {
 			success: true,
 			type: "rpc"
 		};
-		this._connection.send(JSON.stringify(response));
-		return true;
+		return sendRpcResponseIfOpen(this._connection, response);
 	}
 	/**
 	* End the stream and send the final chunk (if any)
@@ -6352,8 +6425,7 @@ var StreamingResponse = class {
 			success: true,
 			type: "rpc"
 		};
-		this._connection.send(JSON.stringify(response));
-		return true;
+		return sendRpcResponseIfOpen(this._connection, response);
 	}
 	/**
 	* Send an error to the client and close the stream
@@ -6369,11 +6441,10 @@ var StreamingResponse = class {
 			success: false,
 			type: "rpc"
 		};
-		this._connection.send(JSON.stringify(response));
-		return true;
+		return sendRpcResponseIfOpen(this._connection, response);
 	}
 };
 //#endregion
-export { Agent, DEFAULT_AGENT_STATIC_OPTIONS, DurableObjectOAuthClientProvider, MCP_SERVER_ID_MAX_LENGTH, MessageType, SUB_PREFIX, SqlError, StreamingResponse, __DO_NOT_USE_WILL_BREAK__agentContext, callable, camelCaseToKebabCase, createHeaderBasedEmailResolver, getAgentByName, getCurrentAgent, getSubAgentByName, normalizeServerId, parseSubAgentPath, routeAgentEmail, routeAgentRequest, routeSubAgentRequest, unstable_callable };
+export { Agent, DEFAULT_AGENT_STATIC_OPTIONS, DurableObjectOAuthClientProvider, MCP_SERVER_ID_MAX_LENGTH, MessageType, SUB_PREFIX, SqlError, StreamingResponse, __DO_NOT_USE_WILL_BREAK__agentContext, callable, camelCaseToKebabCase, createHeaderBasedEmailResolver, getAgentByName, getCurrentAgent, getSubAgentByName, isDurableObjectCodeUpdateReset, isPlatformTransientError, normalizeServerId, parseSubAgentPath, routeAgentEmail, routeAgentRequest, routeSubAgentRequest, unstable_callable };
 
 //# sourceMappingURL=index.js.map