agents 0.23.0 → 0.24.0

package/dist/{src-DlSHshb2.js → src-BNU3ZiJM.js}

@@ -5,22 +5,24 @@ import { n as getCurrentAgent$1, t as __DO_NOT_USE_WILL_BREAK__agentContext } fr
 import "./internal_context.js";
 import { copyCallableMetadata, decoratedMethods, getCallableMetadata, isCallableMethod } from "./callable-decorator.js";
 import "./types.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
 import { signAgentHeaders } from "./email.js";
 import { sendAgentEmail } from "./email-send.js";
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
 import { n as withInvocationScope, r as writeSpanAttributes, t as tracer } from "./cloudflare-Dzvc7V2N.js";
 import { parseSubAgentPath } from "./sub-routing.js";
-import { t as LifecycleCapability } from "./capability-BjSKYpzg.js";
+import { a as getConnectionFlag, c as isConnectionReadonly, d as setConnectionProtocolEnabled, f as setConnectionReadonly, i as ensureConnectionWrapped, l as registerInternalConnectionKeys, o as getConnectionRawState, s as isConnectionProtocolEnabled, t as WebSockets, u as setConnectionFlag } from "./websockets-D7IzWbZb.js";
+import { t as LifecycleCapability } from "./capability-B4WbF81e.js";
 import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
-import { a as abortWithoutAlarmRetry, i as setLifecycleRouteTransport, n as setLifecycleEventSink, r as setLifecycleHostInvoker, t as Lifecycle } from "./lifecycle-CMRGjZdw.js";
+import { a as abortWithoutAlarmRetry, i as setLifecycleRouteTransport, n as setLifecycleEventSink, r as setLifecycleHostInvoker, t as Lifecycle } from "./lifecycle-Mm_jQh7r.js";
 import { isErrorRetryable, tryN, validateRetryOptions } from "./retries.js";
 import { SqlError } from "./sql-error.js";
-import { o as callablesFromDecorated, t as WebSockets } from "./websockets-DUfRHPRq.js";
-import { a as ensureMcpServerTable, d as DisposableStore, i as normalizeServerId, l as RPC_DO_PREFIX, o as MCPConnectionState, t as MCPClientManager } from "./client-jagG8a9_.js";
+import { a as ensureMcpServerTable, d as DisposableStore, i as normalizeServerId, l as RPC_DO_PREFIX, o as MCPConnectionState, t as MCPClientManager } from "./client-fyQrLGkD.js";
 import { DurableObjectOAuthClientProvider } from "./mcp/client/do-oauth-client-provider.js";
 import { genericObservability } from "./observability/index.js";
-import { n as setSchedulerCallbackResolver, t as Scheduler } from "./scheduler-DD9NdYbF.js";
-import { n as setTaskDefinitionResolver, r as setTaskRoutedMemoryLimitHandler, t as Tasks } from "./tasks-ylZgBjhj.js";
+import { n as setSchedulerCallbackResolver, t as Scheduler } from "./scheduler-D_KHqxBa.js";
+import { n as setQueueCallbackResolver, t as Queue } from "./queue-BC9F5cUo.js";
+import { n as setTaskDefinitionResolver, r as setTaskRoutedMemoryLimitHandler, t as Tasks } from "./tasks-D4nLqVSI.js";
+import { State } from "./state/index.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { DurableObject, RpcTarget, exports } from "cloudflare:workers";
 import { nanoid } from "nanoid";
@@ -412,14 +414,16 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 	}
 	/**
 	* Clean root-owned bookkeeping for a sub-tree of facets: bulk-cancel
-	* schedules and routed Task wake mirrors under the owner-path prefix,
-	* and delete root-side facet fiber recovery leases for the same sub-tree.
+	* schedules, queue items, and routed Task wake mirrors under the
+	* owner-path prefix, and delete root-side facet fiber recovery leases for
+	* the same sub-tree.
 	*/
 	async cleanupPrefix(ownerPath) {
 		const prefix = agentPathKey(ownerPath);
 		if (prefix) {
 			await _classPrivateFieldGet2(_host, this).scheduler.__DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix);
 			await _classPrivateFieldGet2(_host, this).tasks.__DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix);
+			await _classPrivateFieldGet2(_host, this)._queue.__DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix);
 		}
 		this.deleteRunRowsForPrefix(ownerPath);
 		await _classPrivateFieldGet2(_host, this)._syncHostJobs();
@@ -747,12 +751,12 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 	async setConnectionState(connectionId, state) {
 		const connection = _classPrivateFieldGet2(_host, this)._webSockets.getConnection(connectionId);
 		if (!connection || !this.connectionHasChildTarget(connection)) return null;
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		ensureConnectionWrapped(connection);
 		connection.setState(state);
 		return this.getForwardedState(connection);
 	}
 	connectionTargetPath(connection) {
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		ensureConnectionWrapped(connection);
 		const outerUri = _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
 		if (typeof outerUri !== "string") return null;
 		return _assertClassBrand(_DynamicAgentsInternal_brand, this, _pathFromOuterUri).call(this, outerUri)?.path ?? null;
@@ -762,7 +766,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		return a.every((step, index) => step.className === b[index]?.className && step.name === b[index]?.name);
 	}
 	connectionHasChildTarget(connection) {
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		ensureConnectionWrapped(connection);
 		return typeof _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY) === "string";
 	}
 	connectionTargetsChild(connection) {
@@ -799,7 +803,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 			const request = new Request(meta.uri ?? "http://placeholder/", { headers: meta.requestHeaders });
 			if (await this.forwardWebSocketConnect(connection, request, { gate: true })) return;
 			if (_classPrivateFieldGet2(_host, this).shouldConnectionBeReadonly(connection, { request })) _classPrivateFieldGet2(_host, this).setConnectionReadonly(connection, true);
-			if (!_classPrivateFieldGet2(_host, this).shouldSendProtocolMessages(connection, { request })) _classPrivateFieldGet2(_host, this)._setConnectionNoProtocol(connection);
+			if (!_classPrivateFieldGet2(_host, this).shouldSendProtocolMessages(connection, { request })) setConnectionProtocolEnabled(connection, false);
 			const childTags = await _classPrivateFieldGet2(_host, this).getConnectionTags(connection, { request });
 			connection.tags = [connection.id, ...childTags.filter((tag) => tag !== connection.id)];
 			this.storeVirtualConnection(connection);
@@ -881,7 +885,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 			removeEventListener() {}
 		};
 		stored.connection = connection;
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+		ensureConnectionWrapped(connection);
 		return connection;
 	}
 	storeVirtualConnection(connection) {
@@ -921,8 +925,7 @@ var DynamicAgentsInternal = class extends LifecycleCapability {
 		for (const meta of metas) _classPrivateFieldGet2(_virtualConnections, this).set(meta.id, { meta });
 	}
 	getRawConnectionState(connection) {
-		_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
-		return _classPrivateFieldGet2(_host, this)._rawStateAccessors.get(connection)?.getRaw() ?? null;
+		return getConnectionRawState(connection);
 	}
 	getForwardedState(connection) {
 		const raw = this.getRawConnectionState(connection);
@@ -1022,7 +1025,7 @@ function _reportConnectionOperationFailure(connectionId, operation, error) {
 	});
 }
 function _connectionMetaForPath(connection, ownerPath) {
-	_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+	ensureConnectionWrapped(connection);
 	const outerUri = _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
 	if (typeof outerUri !== "string") return null;
 	const target = _assertClassBrand(_DynamicAgentsInternal_brand, this, _pathFromOuterUri).call(this, outerUri, ownerPath);
@@ -1072,7 +1075,7 @@ function _createConnectionBridge(connection) {
 	});
 }
 async function _resolveConnection(connection, request, options = { gate: false }) {
-	_classPrivateFieldGet2(_host, this)._ensureConnectionWrapped(connection);
+	ensureConnectionWrapped(connection);
 	const outerUri = _classPrivateFieldGet2(_host, this)._unsafe_getConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY);
 	const uri = typeof outerUri === "string" ? outerUri : connection.uri;
 	if (!uri) return null;
@@ -1213,12 +1216,6 @@ function sendRpcResponseIfOpen(connection, response) {
 function isRPCRequest(msg) {
 	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "rpc" && "id" in msg && typeof msg.id === "string" && "method" in msg && typeof msg.method === "string" && "args" in msg && Array.isArray(msg.args);
 }
-/**
-* Type guard for state update messages
-*/
-function isStateUpdateMessage(msg) {
-	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "cf_agent_state" && "state" in msg;
-}
 const _fiberALS = new AsyncLocalStorage();
 const DEFAULT_KEEP_ALIVE_INTERVAL_MS = 3e4;
 const DEFAULT_AGENT_TOOL_RECOVERY_TIMEOUT_MS = 2e3;
@@ -1247,57 +1244,15 @@ const DETACHED_NOTIFY_CALLBACK = "_cfDetachedNotifyFinish";
 /**
 * Schema version for the Agent's internal SQLite tables.
 * Bump this when adding new tables, columns, or migrations.
-* The constructor stores this as a row in cf_agents_state and checks it
-* on wake to skip DDL on established DOs.
+* The constructor stores this under a namespaced KV key (the same convention
+* every capability uses for its own schema version) and checks it on wake to
+* skip DDL on established DOs.
 */
 const CURRENT_SCHEMA_VERSION = 11;
-const SCHEMA_VERSION_ROW_ID = "cf_schema_version";
-const STATE_ROW_ID = "cf_state_row_id";
-const STATE_WAS_CHANGED = "cf_state_was_changed";
+const SCHEMA_VERSION_KEY = "cf_agents:schema_version";
+const LEGACY_SCHEMA_VERSION_ROW_ID = "cf_schema_version";
 const DEFAULT_STATE = {};
-/**
-* Internal key used to store the readonly flag in connection state.
-* Prefixed with _cf_ to avoid collision with user state keys.
-*/
-const CF_READONLY_KEY = "_cf_readonly";
-/**
-* Internal key used to store the no-protocol flag in connection state.
-* When set, protocol messages (identity, state sync, MCP servers) are not
-* sent to this connection — neither on connect nor via broadcasts.
-*/
-const CF_NO_PROTOCOL_KEY = "_cf_no_protocol";
-/**
-* The set of all internal keys stored in connection state that must be
-* hidden from user code and preserved across setState calls.
-*/
-const CF_INTERNAL_KEYS = /* @__PURE__ */ new Set([
-	CF_READONLY_KEY,
-	CF_NO_PROTOCOL_KEY,
-	"_cf_voiceInCall",
-	CF_SUB_AGENT_OUTER_URL_KEY,
-	CF_SUB_AGENT_TAGS_KEY
-]);
-/** Check if a raw connection state object contains any internal keys. */
-function rawHasInternalKeys(raw) {
-	for (const key of Object.keys(raw)) if (CF_INTERNAL_KEYS.has(key)) return true;
-	return false;
-}
-/** Return a copy of `raw` with all internal keys removed, or null if no user keys remain. */
-function stripInternalKeys(raw) {
-	const result = {};
-	let hasUserKeys = false;
-	for (const key of Object.keys(raw)) if (!CF_INTERNAL_KEYS.has(key)) {
-		result[key] = raw[key];
-		hasUserKeys = true;
-	}
-	return hasUserKeys ? result : null;
-}
-/** Return a copy containing only the internal keys present in `raw`. */
-function extractInternalFlags(raw) {
-	const result = {};
-	for (const key of Object.keys(raw)) if (CF_INTERNAL_KEYS.has(key)) result[key] = raw[key];
-	return result;
-}
+registerInternalConnectionKeys("_cf_voiceInCall", CF_SUB_AGENT_OUTER_URL_KEY, CF_SUB_AGENT_TAGS_KEY);
 /** Max length for error strings broadcast to clients. */
 const MAX_ERROR_STRING_LENGTH = 500;
 /**
@@ -1388,27 +1343,6 @@ const DEFAULT_AGENT_STATIC_OPTIONS = {
 	*/
 	maxAlarmMemoryLimitStrikes: 3
 };
-/**
-* Parse the raw `retry_options` TEXT column from a SQLite row into a
-* typed `RetryOptions` object, or `undefined` if not set.
-*/
-function parseRetryOptions(row) {
-	const raw = row.retry_options;
-	if (typeof raw !== "string") return void 0;
-	return JSON.parse(raw);
-}
-/**
-* Resolve per-task retry options against class-level defaults and call
-* `tryN`. This is the retry-execution path for queue flush; Scheduler owns
-* its own copy for schedule callbacks.
-*/
-function resolveRetryConfig(taskRetry, defaults) {
-	return {
-		maxAttempts: taskRetry?.maxAttempts ?? defaults.maxAttempts,
-		baseDelayMs: taskRetry?.baseDelayMs ?? defaults.baseDelayMs,
-		maxDelayMs: taskRetry?.maxDelayMs ?? defaults.maxDelayMs
-	};
-}
 /** Compatibility alias for the lifecycle-owned current Agent accessor. */
 const getCurrentAgent = getCurrentAgent$1;
 /**
@@ -1433,7 +1367,7 @@ function withAgentContext(method) {
 /**
 * Base class for creating Agent implementations
 * @template Env Environment type containing bindings
-* @template State State type to store within the Agent
+* @template TState State type to store within the Agent
 */
 var Agent = class Agent extends DurableObject {
 	/** Run user initialization after lifecycle components have started. */
@@ -1505,31 +1439,16 @@ var Agent = class Agent extends DurableObject {
 		return this.ctx.id.toString();
 	}
 	/**
-	* Current state of the Agent
+	* Current state of the Agent.
+	*
+	* Delegates to the State capability, which owns lazy load and the
+	* in-memory cache; Agent seeds `initialState` on first access.
 	*/
 	get state() {
-		if (this._state !== DEFAULT_STATE) return this._state;
-		const result = this.sql`
-      SELECT state FROM cf_agents_state WHERE id = ${STATE_ROW_ID}
-    `;
-		if (result.length > 0) {
-			const state = result[0].state;
-			try {
-				this._state = JSON.parse(state);
-			} catch (e) {
-				console.error("Failed to parse stored state, falling back to initialState:", e);
-				if (this.initialState !== DEFAULT_STATE) {
-					this._state = this.initialState;
-					this._setStateInternal(this.initialState);
-				} else {
-					this.sql`DELETE FROM cf_agents_state WHERE id = ${STATE_ROW_ID}`;
-					return;
-				}
-			}
-			return this._state;
-		}
-		if (this.initialState === DEFAULT_STATE) return;
-		this._setStateInternal(this.initialState);
+		const stored = this._state.get();
+		if (stored !== void 0) return stored;
+		if (this.initialState === DEFAULT_STATE) return void 0;
+		this._state.set(this.initialState, "server");
 		return this.initialState;
 	}
 	get _resolvedOptions() {
@@ -1615,26 +1534,9 @@ var Agent = class Agent extends DurableObject {
 	* local dev and the constructor only runs once per DO instance).
 	*/
 	_ensureSchema() {
-		this.sql`
-      CREATE TABLE IF NOT EXISTS cf_agents_state (
-        id TEXT PRIMARY KEY NOT NULL,
-        state TEXT
-      )
-    `;
-		const versionRow = this.sql`
-      SELECT state FROM cf_agents_state WHERE id = ${SCHEMA_VERSION_ROW_ID}
-    `;
-		const schemaVersion = versionRow.length > 0 ? Number(versionRow[0].state) : 0;
+		const schemaVersion = this._readSchemaVersion();
 		if (schemaVersion < CURRENT_SCHEMA_VERSION) {
 			ensureMcpServerTable(this.ctx.storage);
-			this.sql`
-        CREATE TABLE IF NOT EXISTS cf_agents_queues (
-          id TEXT PRIMARY KEY NOT NULL,
-          payload TEXT,
-          callback TEXT,
-          created_at INTEGER DEFAULT (unixepoch())
-        )
-      `;
 			const addColumnIfNotExists = (sql) => {
 				try {
 					this.ctx.storage.sql.exec(sql);
@@ -1642,7 +1544,6 @@ var Agent = class Agent extends DurableObject {
 					if (!(error instanceof Error ? error.message : String(error)).toLowerCase().includes("duplicate column")) throw error;
 				}
 			};
-			addColumnIfNotExists("ALTER TABLE cf_agents_queues ADD COLUMN retry_options TEXT");
 			this.sql`
         CREATE TABLE IF NOT EXISTS cf_agents_workflows (
           id TEXT PRIMARY KEY NOT NULL,
@@ -1667,7 +1568,6 @@ var Agent = class Agent extends DurableObject {
 			this.sql`
         CREATE INDEX IF NOT EXISTS idx_workflows_name ON cf_agents_workflows(workflow_name)
       `;
-			this.ctx.storage.sql.exec("DELETE FROM cf_agents_state WHERE id = ?", STATE_WAS_CHANGED);
 			this.sql`
         CREATE TABLE IF NOT EXISTS cf_agents_runs (
           id TEXT PRIMARY KEY NOT NULL,
@@ -1752,10 +1652,7 @@ var Agent = class Agent extends DurableObject {
 			addColumnIfNotExists("ALTER TABLE cf_agent_tool_runs ADD COLUMN detached_no_progress_budget_ms INTEGER");
 			addColumnIfNotExists("ALTER TABLE cf_agent_tool_runs ADD COLUMN last_progress_at INTEGER");
 			addColumnIfNotExists("ALTER TABLE cf_agent_tool_runs ADD COLUMN detached_on_milestones TEXT");
-			this.sql`
-        INSERT OR REPLACE INTO cf_agents_state (id, state)
-        VALUES (${SCHEMA_VERSION_ROW_ID}, ${String(CURRENT_SCHEMA_VERSION)})
-      `;
+			this.ctx.storage.kv.put(SCHEMA_VERSION_KEY, CURRENT_SCHEMA_VERSION);
 		}
 		this._schemaInitialization = {
 			previousVersion: schemaVersion,
@@ -1763,9 +1660,31 @@ var Agent = class Agent extends DurableObject {
 			migrated: schemaVersion < CURRENT_SCHEMA_VERSION
 		};
 	}
+	/**
+	* Read the Agent's schema version from its KV key. A DO created before the
+	* State capability owned `cf_agents_state` has the version as a row in that
+	* table instead: read it once, move it to the key, and delete the row so the
+	* table is left with a single owner. Synchronous (`storage.kv`) because the
+	* constructor gates DDL on it.
+	*/
+	_readSchemaVersion() {
+		const stored = this.ctx.storage.kv.get(SCHEMA_VERSION_KEY);
+		if (stored !== void 0) return stored;
+		if (!(this.ctx.storage.sql.exec("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cf_agents_state'").toArray().length > 0)) return 0;
+		const rows = this.ctx.storage.sql.exec("SELECT state FROM cf_agents_state WHERE id = ?", LEGACY_SCHEMA_VERSION_ROW_ID).toArray();
+		if (rows.length === 0) return 0;
+		const version = Number(rows[0].state) || 0;
+		this.ctx.storage.kv.put(SCHEMA_VERSION_KEY, version);
+		this.ctx.storage.sql.exec("DELETE FROM cf_agents_state WHERE id = ?", LEGACY_SCHEMA_VERSION_ROW_ID);
+		return version;
+	}
 	constructor(ctx, env) {
 		super(ctx, env);
 		this.lifecycle = Lifecycle.install(this, { maxAlarmMemoryLimitStrikes: this._resolvedOptions.maxAlarmMemoryLimitStrikes });
+		this._state = new State({
+			validateStateChange: (nextState, source) => this.validateStateChange(nextState, source),
+			onChanged: (nextState, source) => this._handleStateChanged(nextState, source)
+		});
 		this._webSockets = new WebSockets({
 			handlers: {
 				onConnect: (connection, ctx) => this.onConnect(connection, ctx),
@@ -1773,13 +1692,12 @@ var Agent = class Agent extends DurableObject {
 				onClose: (connection, code, reason, wasClean) => this.onClose(connection, code, reason, wasClean),
 				onError: (connection, error) => this.onError(connection, error)
 			},
-			callables: callablesFromDecorated(this),
+			protocol: false,
+			state: this._state,
 			getConnectionTags: (connection, ctx) => this.getConnectionTags(connection, ctx)
 		});
-		this._state = DEFAULT_STATE;
 		this._disposables = new DisposableStore();
 		this._destroyed = false;
-		this._rawStateAccessors = /* @__PURE__ */ new WeakMap();
 		this._persistenceHookMode = "none";
 		this._isFacet = false;
 		this._protocolBroadcastExcludeIds = /* @__PURE__ */ new Set();
@@ -1797,7 +1715,6 @@ var Agent = class Agent extends DurableObject {
 		this._ParentClass = Object.getPrototypeOf(this).constructor;
 		this.initialState = DEFAULT_STATE;
 		this.observability = genericObservability;
-		this._flushingQueue = false;
 		this.maxConcurrentAgentTools = Infinity;
 		const routeHost = this;
 		setLifecycleRouteTransport(this.lifecycle, {
@@ -1832,6 +1749,20 @@ var Agent = class Agent extends DurableObject {
 			if (typeof method !== "function") return void 0;
 			return (payload, schedule) => method.call(this, payload, schedule);
 		});
+		this._queue = new Queue({
+			retry: this._resolvedOptions.retry,
+			onError: (error) => runInInvocation({
+				agent: this,
+				connection: void 0,
+				request: void 0,
+				email: void 0
+			}, () => this.onError(error))
+		});
+		setQueueCallbackResolver(this._queue, (name) => {
+			const method = this[name];
+			if (typeof method !== "function") return void 0;
+			return (payload, item) => method.call(this, payload, item);
+		});
 		this.tasks = new Tasks({ onError: (error) => this.onError(error) });
 		setTaskRoutedMemoryLimitHandler(this.tasks, (context) => {
 			return this.onAlarmMemoryLimit?.call(this, context);
@@ -1857,7 +1788,7 @@ var Agent = class Agent extends DurableObject {
 				createAuthProvider: (callbackUrl) => this.createMcpOAuthProvider(callbackUrl)
 			});
 		});
-		this.lifecycle.use(this.scheduler).use(this.mcp).use(this._webSockets, { fallback: true }).use(this.tasks).use(this._dynamicAgents);
+		this.lifecycle.use(this.scheduler).use(this._queue).use(this.mcp).use(this._state).use(this._webSockets).use(this.tasks).use(this._dynamicAgents);
 		let mcpBroadcastReady = false;
 		this._disposables.add(this.mcp.onServerStateChanged(() => {
 			if (mcpBroadcastReady) this.broadcastMcpServers();
@@ -1907,7 +1838,7 @@ var Agent = class Agent extends DurableObject {
 		this.onMessage = async (connection, message) => {
 			const replyBridge = dynamicAgentRpcReplyContext.getStore()?.bridge;
 			if (await __DO_NOT_USE_WILL_BREAK__agentContext.exit(() => this._cf_forwardSubAgentWebSocketMessage(connection, message, replyBridge))) return;
-			this._ensureConnectionWrapped(connection);
+			ensureConnectionWrapped(connection);
 			return runInInvocation({
 				agent: this,
 				connection,
@@ -1921,25 +1852,7 @@ var Agent = class Agent extends DurableObject {
 				} catch (_e) {
 					return this._tryCatch(() => _onMessage(connection, message));
 				}
-				if (isStateUpdateMessage(parsed)) {
-					if (this.isConnectionReadonly(connection)) {
-						connection.send(JSON.stringify({
-							type: "cf_agent_state_error",
-							error: "Connection is readonly"
-						}));
-						return;
-					}
-					try {
-						this._setStateInternal(parsed.state, connection);
-					} catch (e) {
-						console.error("[Agent] State update rejected:", e);
-						connection.send(JSON.stringify({
-							type: "cf_agent_state_error",
-							error: "State update rejected"
-						}));
-					}
-					return;
-				}
+				if (this._webSockets.applyStateFrame(connection, parsed)) return;
 				if (isRPCRequest(parsed)) {
 					try {
 						const { id, method, args } = parsed;
@@ -2003,7 +1916,7 @@ var Agent = class Agent extends DurableObject {
 		};
 		const _onConnect = this.onConnect.bind(this);
 		this.onConnect = async (connection, ctx) => {
-			this._ensureConnectionWrapped(connection);
+			ensureConnectionWrapped(connection);
 			const subAgentOuterUrl = ctx.request.headers.get(SUB_AGENT_OUTER_URL_HEADER);
 			if (subAgentOuterUrl) this._unsafe_setConnectionFlag(connection, CF_SUB_AGENT_OUTER_URL_KEY, subAgentOuterUrl);
 			if (await __DO_NOT_USE_WILL_BREAK__agentContext.exit(() => this._cf_forwardSubAgentWebSocketConnect(connection, ctx.request, { gate: false }))) return;
@@ -2023,11 +1936,10 @@ var Agent = class Agent extends DurableObject {
 								console.warn(`[Agent] ${ctor.name}: sending instance name "${this.name}" to clients via sendIdentityOnConnect (the name is not visible in the URL with custom routing). If this name is sensitive, add \`static options = { sendIdentityOnConnect: false }\` to opt out. Set it to true to silence this message.`);
 							}
 						}
-						connection.send(JSON.stringify({
+						this._webSockets.sendIdentity(connection, {
 							name: this.name,
-							agent: camelCaseToKebabCase(this._ParentClass.name),
-							type: "cf_agent_identity"
-						}));
+							agent: camelCaseToKebabCase(this._ParentClass.name)
+						});
 					}
 					const wasExcludedFromStateInitBroadcast = this._protocolBroadcastExcludeIds.has(connection.id);
 					let currentState;
@@ -2037,15 +1949,12 @@ var Agent = class Agent extends DurableObject {
 					} finally {
 						if (!wasExcludedFromStateInitBroadcast) this._protocolBroadcastExcludeIds.delete(connection.id);
 					}
-					if (currentState !== void 0) connection.send(JSON.stringify({
-						state: currentState,
-						type: "cf_agent_state"
-					}));
+					if (currentState !== void 0) this._webSockets.sendState(connection);
 					connection.send(JSON.stringify({
 						mcp: this.getMcpServers(),
 						type: "cf_agent_mcp_servers"
 					}));
-				} else this._setConnectionNoProtocol(connection);
+				} else this._webSockets.setProtocolEnabled(connection, false);
 				this._emit("connect", { connectionId: connection.id });
 				await this._replayAgentToolRuns(connection);
 				return this._tryCatch(() => _onConnect(connection, ctx));
@@ -2142,13 +2051,14 @@ var Agent = class Agent extends DurableObject {
 		for (const conn of this.getConnections()) if (!this.isConnectionProtocolEnabled(conn)) exclude.push(conn.id);
 		this.broadcast(msg, exclude);
 	}
-	_setStateInternal(nextState, source = "server") {
-		this.validateStateChange(nextState, source);
-		this._state = nextState;
-		this.sql`
-      INSERT OR REPLACE INTO cf_agents_state (id, state)
-      VALUES (${STATE_ROW_ID}, ${JSON.stringify(nextState)})
-    `;
+	/**
+	* React to a persisted state change from the State capability.
+	*
+	* Reproduces the pre-migration steps 3-4: broadcast the new state to
+	* protocol-enabled connections (excluding the originating connection) and
+	* run the notification hook off the invocation tail.
+	*/
+	_handleStateChanged(nextState, source) {
 		this._broadcastProtocol(JSON.stringify({
 			state: nextState,
 			type: "cf_agent_state"
@@ -2180,69 +2090,7 @@ var Agent = class Agent extends DurableObject {
 	setState(state) {
 		const store = __DO_NOT_USE_WILL_BREAK__agentContext.getStore();
 		if (store?.connection && this.isConnectionReadonly(store.connection)) throw new Error("Connection is readonly");
-		this._setStateInternal(state, "server");
-	}
-	/**
-	* Wraps connection.state and connection.setState so that internal
-	* _cf_-prefixed flags (readonly, no-protocol) are hidden from user code
-	* and cannot be accidentally overwritten.
-	*
-	* Idempotent — safe to call multiple times on the same connection.
-	* After hibernation, the _rawStateAccessors WeakMap is empty but the
-	* connection's state getter still reads from the persisted WebSocket
-	* attachment. Calling this method re-captures the raw getter so that
-	* predicate methods (isConnectionReadonly, isConnectionProtocolEnabled)
-	* work correctly post-hibernation.
-	*/
-	_ensureConnectionWrapped(connection) {
-		if (this._rawStateAccessors.has(connection)) return;
-		const descriptor = Object.getOwnPropertyDescriptor(connection, "state");
-		let getRaw;
-		let setRaw;
-		if (descriptor?.get) {
-			getRaw = descriptor.get.bind(connection);
-			setRaw = connection.setState.bind(connection);
-		} else {
-			let rawState = connection.state ?? null;
-			getRaw = () => rawState;
-			setRaw = (state) => {
-				rawState = state;
-				return rawState;
-			};
-		}
-		this._rawStateAccessors.set(connection, {
-			getRaw,
-			setRaw
-		});
-		Object.defineProperty(connection, "state", {
-			configurable: true,
-			enumerable: true,
-			get() {
-				const raw = getRaw();
-				if (raw != null && typeof raw === "object" && rawHasInternalKeys(raw)) return stripInternalKeys(raw);
-				return raw;
-			}
-		});
-		Object.defineProperty(connection, "setState", {
-			configurable: true,
-			writable: true,
-			value(stateOrFn) {
-				const raw = getRaw();
-				const flags = raw != null && typeof raw === "object" ? extractInternalFlags(raw) : {};
-				const hasFlags = Object.keys(flags).length > 0;
-				let newUserState;
-				if (typeof stateOrFn === "function") newUserState = stateOrFn(hasFlags ? stripInternalKeys(raw) : raw);
-				else newUserState = stateOrFn;
-				if (hasFlags) {
-					if (newUserState != null && typeof newUserState === "object") return setRaw({
-						...newUserState,
-						...flags
-					});
-					return setRaw(flags);
-				}
-				return setRaw(newUserState);
-			}
-		});
+		this._state.set(state, "server");
 	}
 	/**
 	* Mark a connection as readonly or readwrite
@@ -2250,17 +2098,7 @@ var Agent = class Agent extends DurableObject {
 	* @param readonly Whether the connection should be readonly (default: true)
 	*/
 	setConnectionReadonly(connection, readonly = true) {
-		this._ensureConnectionWrapped(connection);
-		const accessors = this._rawStateAccessors.get(connection);
-		const raw = accessors.getRaw() ?? {};
-		if (readonly) accessors.setRaw({
-			...raw,
-			[CF_READONLY_KEY]: true
-		});
-		else {
-			const { [CF_READONLY_KEY]: _, ...rest } = raw;
-			accessors.setRaw(Object.keys(rest).length > 0 ? rest : null);
-		}
+		setConnectionReadonly(connection, readonly);
 	}
 	/**
 	* Check if a connection is marked as readonly.
@@ -2271,8 +2109,7 @@ var Agent = class Agent extends DurableObject {
 	* @returns True if the connection is readonly
 	*/
 	isConnectionReadonly(connection) {
-		this._ensureConnectionWrapped(connection);
-		return !!this._rawStateAccessors.get(connection).getRaw()?.[CF_READONLY_KEY];
+		return isConnectionReadonly(connection);
 	}
 	/**
 	* ⚠️ INTERNAL — DO NOT USE IN APPLICATION CODE. ⚠️
@@ -2287,30 +2124,20 @@ var Agent = class Agent extends DurableObject {
 	* @internal
 	*/
 	_unsafe_getConnectionFlag(connection, key) {
-		this._ensureConnectionWrapped(connection);
-		return this._rawStateAccessors.get(connection).getRaw()?.[key];
+		return getConnectionFlag(connection, key);
 	}
 	/**
 	* ⚠️ INTERNAL — DO NOT USE IN APPLICATION CODE. ⚠️
 	*
 	* Write an internal `_cf_`-prefixed flag to the raw connection state,
 	* bypassing the user-facing state wrapper. The key must be registered
-	* in `CF_INTERNAL_KEYS` so it is preserved across user `setState` calls
-	* and hidden from `connection.state`.
+	* with `registerInternalConnectionKeys` so it is preserved across user
+	* `setState` calls and hidden from `connection.state`.
 	*
 	* @internal
 	*/
 	_unsafe_setConnectionFlag(connection, key, value) {
-		this._ensureConnectionWrapped(connection);
-		const accessors = this._rawStateAccessors.get(connection);
-		const raw = accessors.getRaw() ?? {};
-		if (value === void 0) {
-			const { [key]: _, ...rest } = raw;
-			accessors.setRaw(Object.keys(rest).length > 0 ? rest : null);
-		} else accessors.setRaw({
-			...raw,
-			[key]: value
-		});
+		setConnectionFlag(connection, key, value);
 	}
 	/**
 	* Override this method to determine if a connection should be readonly on connect
@@ -2351,21 +2178,7 @@ var Agent = class Agent extends DurableObject {
 	* @returns True if the connection receives protocol messages
 	*/
 	isConnectionProtocolEnabled(connection) {
-		this._ensureConnectionWrapped(connection);
-		return !this._rawStateAccessors.get(connection).getRaw()?.[CF_NO_PROTOCOL_KEY];
-	}
-	/**
-	* Mark a connection as having protocol messages disabled.
-	* Called internally when shouldSendProtocolMessages returns false.
-	*/
-	_setConnectionNoProtocol(connection) {
-		this._ensureConnectionWrapped(connection);
-		const accessors = this._rawStateAccessors.get(connection);
-		const raw = accessors.getRaw() ?? {};
-		accessors.setRaw({
-			...raw,
-			[CF_NO_PROTOCOL_KEY]: true
-		});
+		return isConnectionProtocolEnabled(connection);
 	}
 	/**
 	* Called before the Agent's state is persisted and broadcast.
@@ -2610,111 +2423,42 @@ var Agent = class Agent extends DurableObject {
 		});
 	}
 	/**
-	* Queue a task to be executed in the future
+	* Queue a task to run in the background.
+	*
+	* The item is durable: it runs from the Lifecycle alarm event loop after
+	* this call returns, in push order, one at a time, with retries per
+	* `options.retry`, and survives the Durable Object leaving memory.
 	* @param callback Name of the method to call
 	* @param payload Payload to pass to the callback
 	* @param options Options for the queued task
 	* @param options.retry Retry options for the callback execution
+	* @param options.id Stable id; a push with an existing id replaces that item
 	* @returns The ID of the queued task
 	*/
 	async queue(callback, payload, options) {
-		const id = nanoid(9);
 		if (typeof callback !== "string") throw new Error("Callback must be a string");
 		if (typeof this[callback] !== "function") throw new Error(`this.${callback} is not a function`);
-		if (options?.retry) validateRetryOptions(options.retry, this._resolvedOptions.retry);
-		const retryJson = options?.retry ? JSON.stringify(options.retry) : null;
-		this.sql`
-      INSERT OR REPLACE INTO cf_agents_queues (id, payload, callback, retry_options)
-      VALUES (${id}, ${JSON.stringify(payload)}, ${callback}, ${retryJson})
-    `;
-		this._emit("queue:create", {
-			callback,
-			id
-		});
-		this._flushQueue().catch((e) => {
-			console.error("Error flushing queue:", e);
-		});
-		return id;
-	}
-	async _flushQueue() {
-		if (this._flushingQueue) return;
-		this._flushingQueue = true;
-		try {
-			while (true) {
-				const result = this.sql`
-        SELECT * FROM cf_agents_queues
-        ORDER BY created_at ASC
-      `;
-				if (!result || result.length === 0) break;
-				for (const row of result || []) {
-					const callback = this[row.callback];
-					if (!callback) {
-						console.error(`callback ${row.callback} not found`);
-						await this.dequeue(row.id);
-						continue;
-					}
-					const { connection, request, email } = __DO_NOT_USE_WILL_BREAK__agentContext.getStore() || {};
-					await runInInvocation({
-						agent: this,
-						connection,
-						request,
-						email
-					}, async () => {
-						const { maxAttempts, baseDelayMs, maxDelayMs } = resolveRetryConfig(parseRetryOptions(row), this._resolvedOptions.retry);
-						const parsedPayload = JSON.parse(row.payload);
-						try {
-							await tryN(maxAttempts, async (attempt) => {
-								if (attempt > 1) this._emit("queue:retry", {
-									callback: row.callback,
-									id: row.id,
-									attempt,
-									maxAttempts
-								});
-								await callback.bind(this)(parsedPayload, row);
-							}, {
-								baseDelayMs,
-								maxDelayMs
-							});
-						} catch (e) {
-							console.error(`queue callback "${row.callback}" failed after ${maxAttempts} attempts`, e);
-							this._emit("queue:error", {
-								callback: row.callback,
-								id: row.id,
-								error: e instanceof Error ? e.message : String(e),
-								attempts: maxAttempts
-							});
-							try {
-								await this.onError(e);
-							} catch {}
-						} finally {
-							this.dequeue(row.id);
-						}
-					}, { detached: true });
-				}
-			}
-		} finally {
-			this._flushingQueue = false;
-		}
+		return (await this._queue.push(callback, payload, options)).id;
 	}
 	/**
 	* Dequeue a task by ID
 	* @param id ID of the task to dequeue
 	*/
 	dequeue(id) {
-		this.sql`DELETE FROM cf_agents_queues WHERE id = ${id}`;
+		return this._queue.cancel(id);
 	}
 	/**
 	* Dequeue all tasks
 	*/
 	dequeueAll() {
-		this.sql`DELETE FROM cf_agents_queues`;
+		return this._queue.cancelAll();
 	}
 	/**
 	* Dequeue all tasks by callback
 	* @param callback Name of the callback to dequeue
 	*/
 	dequeueAllByCallback(callback) {
-		this.sql`DELETE FROM cf_agents_queues WHERE callback = ${callback}`;
+		return this._queue.cancelAll(callback);
 	}
 	/**
 	* Get a queued task by ID
@@ -2722,31 +2466,16 @@ var Agent = class Agent extends DurableObject {
 	* @returns The task or undefined if not found
 	*/
 	getQueue(id) {
-		const result = this.sql`
-      SELECT * FROM cf_agents_queues WHERE id = ${id}
-    `;
-		if (!result || result.length === 0) return void 0;
-		const row = result[0];
-		return {
-			...row,
-			payload: JSON.parse(row.payload),
-			retry: parseRetryOptions(row)
-		};
+		return this._queue.get(id);
 	}
 	/**
-	* Get all queues by key and value
+	* Get all queued tasks whose payload has `key` equal to `value`
 	* @param key Key to filter by
 	* @param value Value to filter by
 	* @returns Array of matching QueueItem objects
 	*/
-	getQueues(key, value) {
-		return this.sql`
-      SELECT * FROM cf_agents_queues
-    `.filter((row) => JSON.parse(row.payload)[key] === value).map((row) => ({
-			...row,
-			payload: JSON.parse(row.payload),
-			retry: parseRetryOptions(row)
-		}));
+	async getQueues(key, value) {
+		return (await this._queue.list()).filter((item) => typeof item.payload === "object" && item.payload !== null && item.payload[key] === value);
 	}
 	_lifecycleRouteAddress() {
 		return this._dynamicAgents.lifecycleRouteAddress();
@@ -3540,12 +3269,16 @@ var Agent = class Agent extends DurableObject {
 			}
 		} finally {
 			this._runFiberActiveFibers.delete(id);
-			this._withAgentSpan("finalize_fiber", "fiber", {
-				"cloudflare.agents.fiber.id": id,
-				"cloudflare.agents.fiber.name": name
-			}, () => {
-				this.sql`DELETE FROM cf_agents_runs WHERE id = ${id}`;
-			});
+			try {
+				this._withAgentSpan("finalize_fiber", "fiber", {
+					"cloudflare.agents.fiber.id": id,
+					"cloudflare.agents.fiber.name": name
+				}, () => {
+					this.sql`DELETE FROM cf_agents_runs WHERE id = ${id}`;
+				});
+			} catch (error) {
+				console.error(`[Agent] Failed to finalize fiber "${name}" (${id}); leaving run row for recovery:`, error);
+			}
 			dispose();
 			if (root && registeredFacetRun) try {
 				await root._cf_unregisterFacetRun(this.selfPath, id);
@@ -6960,4 +6693,4 @@ var StreamingResponse = class {
 //#endregion
 export { routeAgentEmail as a, getCurrentAgent as i, DEFAULT_AGENT_STATIC_OPTIONS as n, StreamingResponse as r, Agent as t };
 
-//# sourceMappingURL=src-DlSHshb2.js.map
+//# sourceMappingURL=src-BNU3ZiJM.js.map