@happyvertical/smrt-agents 0.49.2 → 0.49.4

package/dist/server.js

@@ -1,7 +1,10 @@
 import { n as executeAsPrincipal, r as AgentConfig } from "./chunks/execute-as-principal-DIyBp1oE.js";
 import { i as loadManifestsFromPackages, n as extractAgentPackagesFromConfig, r as loadManifestsFromConfig, t as extractAgentManifest } from "./chunks/manifest-utils-CtMyFQDx.js";
+import { ObjectRegistry, SmrtObject, field, smrt } from "@happyvertical/smrt-core";
 import { sanitizeConfig } from "@happyvertical/smrt-config";
-import { createHash, randomBytes } from "node:crypto";
+import { TenantScoped, getTenantId, tenantId } from "@happyvertical/smrt-tenancy";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { SmrtJobCollection, backgroundEligible, createHmacDurableJobPayloadSigner, getActiveJobExecutionContext, isRunnerExecutionContext } from "@happyvertical/smrt-jobs";
 //#region src/server/api-routes.ts
 function buildRouteMap(manifests) {
 	const routes = /* @__PURE__ */ new Map();
@@ -92,6 +95,16 @@ var InMemoryDataSurfaceActionStateStore = class {
 		record.consumedBy = idempotencyKey;
 		return true;
 	}
+	consumeTokenAndReserveIdempotency(token, idempotencyKey, scope, reservation) {
+		const tokenRecord = this.tokens.get(token);
+		if (!tokenRecord || tokenRecord.consumedBy && tokenRecord.consumedBy !== idempotencyKey) return;
+		if (!this.idempotency.get(scope)) this.idempotency.set(scope, {
+			status: "reserved",
+			...reservation
+		});
+		tokenRecord.consumedBy = idempotencyKey;
+		return this.idempotency.get(scope);
+	}
 	getIdempotency(key) {
 		return this.idempotency.get(key);
 	}
@@ -169,6 +182,22 @@ function stable(value) {
 function fingerprint(value) {
 	return createHash("sha256").update(stable(value)).digest("hex");
 }
+function envelopeBinding(envelope, key) {
+	return createHmacDurableJobPayloadSigner({
+		keyId: "data-surface-envelope-v1",
+		key
+	}).sign(envelope);
+}
+function validSigningKey(key) {
+	return key !== void 0 && (typeof key === "string" ? Buffer.byteLength(key) : key.byteLength) >= 32;
+}
+function bindingMatches(envelope, key) {
+	const { binding, ...unsigned } = envelope;
+	return createHmacDurableJobPayloadSigner({
+		keyId: "data-surface-envelope-v1",
+		key
+	}).verify(unsigned, binding);
+}
 function identityKey(identity) {
 	return stable(canonicalIdentity(identity));
 }
@@ -417,7 +446,7 @@ function createDataSurfaceActionAdapter(options) {
 		}
 		return result(request, true, void 0, outcomesDetails(outcomes));
 	}
-	async function executeBackgroundOnce(request, context, token, reference) {
+	async function executeBackgroundOnce(request, token, reference) {
 		const ownerToken = randomBytes(16).toString("base64url");
 		const executionFingerprint = fingerprint({
 			kind: "background-execution",
@@ -445,19 +474,32 @@ function createDataSurfaceActionAdapter(options) {
 			if (winner.requestFingerprint !== executionFingerprint) return result(request, false, "idempotency_conflict");
 			if (winner.status === "completed") return replayResult(request, winner.result);
 			if (winner.ownerToken === ownerToken) {
+				let refreshed;
+				try {
+					const resolved = await options.resolveDeferredPrincipal?.(reference);
+					if (!resolved || resolved.principal.runAsUserId !== reference.runAsUserId || resolved.principal.tenantId !== reference.tenantId || (resolved.principal.actsAsProfileId ?? null) !== reference.actsAsProfileId || (resolved.onBehalfOfUserId ?? null) !== reference.onBehalfOfUserId || (resolved.agentClass ?? null) !== (reference.agentClass ?? null) || !Array.isArray(resolved.principal.allowedTools)) throw new Error("Deferred data-surface action principal binding could not be resolved safely");
+					refreshed = resolved;
+				} catch (error) {
+					const reason = options.mapError?.(error, request);
+					if (!reason) {
+						await state.releaseIdempotency(executionScope, ownerToken);
+						throw error;
+					}
+					const denied = result(request, false, reason);
+					if (!await state.completeIdempotency(executionScope, ownerToken, denied)) throw new Error("Lost background action idempotency reservation");
+					return denied;
+				}
 				let executed;
+				let mutationStarted = false;
 				try {
-					const refreshed = await options.resolveDeferredPrincipal?.(reference);
-					if (!refreshed || refreshed.principal.runAsUserId !== reference.runAsUserId || refreshed.principal.tenantId !== reference.tenantId || (refreshed.principal.actsAsProfileId ?? null) !== reference.actsAsProfileId || (refreshed.onBehalfOfUserId ?? null) !== reference.onBehalfOfUserId || (refreshed.agentClass ?? null) !== (reference.agentClass ?? null) || !Array.isArray(refreshed.principal.allowedTools)) throw new Error("Deferred data-surface action principal binding could not be resolved safely");
 					const { permissions: _permissions, ...livePrincipal } = refreshed;
-					executed = await authorizedApply(request, {
-						...context,
-						principal: livePrincipal
-					}, token, false);
+					executed = await authorizedApply(request, { principal: livePrincipal }, token, false, () => {
+						mutationStarted = true;
+					});
 				} catch (error) {
 					const reason = options.mapError?.(error, request);
 					if (!reason) {
-						await state.releaseIdempotency(executionScope, ownerToken);
+						if (!mutationStarted) await state.releaseIdempotency(executionScope, ownerToken);
 						throw error;
 					}
 					executed = result(request, false, reason);
@@ -473,7 +515,7 @@ function createDataSurfaceActionAdapter(options) {
 		}
 		return result(request, false, "idempotency_in_progress");
 	}
-	async function authorizedApply(request, context, token, allowBackground) {
+	async function authorizedApply(request, context, token, allowBackground, beforeMutation) {
 		const idempotencyKey = request.idempotencyKey;
 		if (!idempotencyKey) return result(request, false, "invalid_request");
 		const deferredPrincipalReference = Object.freeze({
@@ -501,13 +543,25 @@ function createDataSurfaceActionAdapter(options) {
 			} else if (invocation.action.confirmation === "required") return result(request, false, "confirmation_required");
 			else if (invocation.selection.revision !== request.expectedRevision) return result(request, false, "stale_revision");
 			if (invocation.action.execution === "background" && allowBackground) {
-				if (!options.backgroundQueue || !options.resolveDeferredPrincipal) return result(request, false, "background_unavailable");
+				if (!options.backgroundQueue || !validIdentifier(options.backgroundHandlerId) || !options.resolveDeferredPrincipal || !validSigningKey(options.deferredEnvelopeSigningKey)) return result(request, false, "background_unavailable");
+				const { confirmationToken: _confirmationToken, ...deferredRequest } = request;
+				const unsignedEnvelope = {
+					version: 1,
+					handlerId: options.backgroundHandlerId ?? "",
+					request: deferredRequest,
+					principal: deferredPrincipalReference,
+					...token ? { previewToken: token } : {}
+				};
 				const queued = await options.backgroundQueue.enqueue({
 					idempotencyKey,
 					identity: request.identity,
 					actionId: request.actionId,
 					rowIds: invocation.selection.rowIds,
-					run: () => executeBackgroundOnce(request, context, token, deferredPrincipalReference)
+					envelope: {
+						...unsignedEnvelope,
+						binding: envelopeBinding(unsignedEnvelope, options.deferredEnvelopeSigningKey)
+					},
+					run: () => executeBackgroundOnce(request, token, deferredPrincipalReference)
 				});
 				return result(request, true, void 0, {
 					accepted: invocation.selection.rowIds.length,
@@ -519,6 +573,7 @@ function createDataSurfaceActionAdapter(options) {
 					jobRequestId: request.requestId
 				});
 			}
+			beforeMutation?.();
 			return executeForeground(request, invocation);
 		});
 	}
@@ -554,16 +609,34 @@ function createDataSurfaceActionAdapter(options) {
 			token = await state.getToken(confirmationToken);
 			if (!token || token.expiresAt <= now()) return result(request, false, "invalid_or_expired_confirmation");
 			if (token.actorUserId !== actorUserId || token.tenantId !== tenantId || token.onBehalfOfUserId !== onBehalfOfUserId || token.actsAsProfileId !== actsAsProfileId || token.agentClass !== agentClass || token.identityKey !== identityKey(request.identity) || token.actionId !== request.actionId || token.requestFingerprint !== requestFingerprintValue) return result(request, false, "confirmation_mismatch");
-			if (!await state.markTokenConsumed(confirmationToken, idempotencyKey)) return result(request, false, "confirmation_replayed");
 		}
+		const backgroundPreflight = await runAsPrincipal({
+			...boundContext.principal,
+			action: "data_surface.action.apply",
+			auditMetadata: boundContext.principal.auditMetadata
+		}, async (run) => {
+			const surface = await options.resolveSurface(run, request.identity);
+			if (identityKey(surface.descriptor.identity) !== identityKey(request.identity)) return void 0;
+			const action = surface.actions[request.actionId];
+			const declared = surface.descriptor.actions.find(({ id }) => id === request.actionId);
+			if (!action || !declared || action.descriptor.id !== declared.id) return void 0;
+			if (action.execution === "background" && (!options.backgroundQueue || !validIdentifier(options.backgroundHandlerId) || !options.resolveDeferredPrincipal || !validSigningKey(options.deferredEnvelopeSigningKey))) return result(request, false, "background_unavailable");
+		});
+		if (backgroundPreflight) return backgroundPreflight;
 		const ownerToken = randomBytes(16).toString("base64url");
+		const reservation = {
+			requestFingerprint: requestFingerprintValue,
+			ownerToken,
+			reservedAt: now()
+		};
+		let firstWinner;
+		if (confirmationToken) {
+			firstWinner = await state.consumeTokenAndReserveIdempotency(confirmationToken, idempotencyKey, idempotencyScope, reservation);
+			if (!firstWinner) return result(request, false, "confirmation_replayed");
+		}
 		const maxPolls = Math.max(1, Math.ceil(idempotencyWaitTimeoutMs / idempotencyPollIntervalMs));
 		for (let poll = 0; poll <= maxPolls; poll += 1) {
-			const winner = await state.reserveIdempotency(idempotencyScope, {
-				requestFingerprint: requestFingerprintValue,
-				ownerToken,
-				reservedAt: now()
-			});
+			const winner = poll === 0 && firstWinner ? firstWinner : await state.reserveIdempotency(idempotencyScope, reservation);
 			if (winner.requestFingerprint !== requestFingerprintValue) return result(request, false, "idempotency_conflict");
 			if (winner.status === "completed") return replayResult(request, winner.result);
 			if (winner.ownerToken === ownerToken) {
@@ -589,12 +662,112 @@ function createDataSurfaceActionAdapter(options) {
 		}
 		return result(request, false, "idempotency_in_progress");
 	}
+	async function executeDeferred(envelope) {
+		if (!validSigningKey(options.deferredEnvelopeSigningKey) || !bindingMatches(envelope, options.deferredEnvelopeSigningKey)) throw new Error("Invalid durable data-surface action envelope binding");
+		const principal = envelope.principal;
+		if (envelope.version !== 1 || !options.backgroundHandlerId || envelope.handlerId !== options.backgroundHandlerId || !principal || !validIdentifier(principal.runAsUserId) || principal.tenantId !== null && !validIdentifier(principal.tenantId) || principal.actsAsProfileId !== null && !validIdentifier(principal.actsAsProfileId) || principal.onBehalfOfUserId !== null && !validIdentifier(principal.onBehalfOfUserId) || principal.agentClass !== void 0 && !validIdentifier(principal.agentClass)) return result(envelope.request, false, "invalid_request");
+		const invalid = validateRequest(envelope.request, "apply");
+		if (invalid) return result(envelope.request, false, invalid);
+		return executeBackgroundOnce(snapshotRequest(envelope.request), envelope.previewToken, Object.freeze({ ...envelope.principal }));
+	}
 	return {
 		preview,
-		apply
+		apply,
+		executeDeferred
 	};
 }
 //#endregion
+//#region src/server/jobs-data-surface-action-queue.ts
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$1(target, key, result);
+	return result;
+};
+var handlers = /* @__PURE__ */ new Map();
+var SmrtDataSurfaceActionTask = class extends SmrtObject {
+	tenantId = null;
+	args = {
+		version: 1,
+		envelope: {}
+	};
+	async run(args = this.args, context) {
+		const envelope = args?.envelope;
+		const executionContext = getActiveJobExecutionContext() ?? context;
+		if (executionContext && !isRunnerExecutionContext(executionContext)) throw new Error("Invalid durable data-surface action job context");
+		let jobTenantId;
+		if (executionContext) {
+			const runnerTenantId = executionContext.job.tenantId;
+			if (runnerTenantId === null) jobTenantId = null;
+			else if (typeof runnerTenantId === "string" && runnerTenantId.length > 0) jobTenantId = runnerTenantId;
+			else throw new Error("Invalid durable data-surface action job tenant");
+		} else jobTenantId = this.tenantId ?? getTenantId() ?? null;
+		if (args?.version !== 1 || envelope?.version !== 1 || typeof envelope.handlerId !== "string" || envelope.handlerId.length === 0 || envelope.principal?.tenantId !== jobTenantId) throw new Error("Invalid durable data-surface action envelope");
+		const handler = handlers.get(envelope.handlerId);
+		if (!handler) throw new Error(`No data-surface action handler registered for ${envelope.handlerId}`);
+		const result = await handler(envelope);
+		if (!result.ok && result.reason === "idempotency_in_progress") throw new Error("Data-surface action outcome requires reconciliation");
+		return result;
+	}
+};
+__decorateClass$1([tenantId({ nullable: true })], SmrtDataSurfaceActionTask.prototype, "tenantId", 2);
+__decorateClass$1([field({
+	type: "json",
+	required: true
+})], SmrtDataSurfaceActionTask.prototype, "args", 2);
+__decorateClass$1([backgroundEligible()], SmrtDataSurfaceActionTask.prototype, "run", 1);
+SmrtDataSurfaceActionTask = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt({
+	tableName: "_smrt_data_surface_action_tasks",
+	api: false,
+	cli: false,
+	mcp: false
+})], SmrtDataSurfaceActionTask);
+function registerDataSurfaceBackgroundActionHandler(handlerId, execute) {
+	if (!handlerId || handlerId.length > 256) throw new Error("Data-surface action handlerId must contain 1-256 characters");
+	const existing = handlers.get(handlerId);
+	if (existing && existing !== execute) throw new Error(`Data-surface action handler already registered: ${handlerId}`);
+	handlers.set(handlerId, execute);
+	return () => {
+		if (handlers.get(handlerId) === execute) handlers.delete(handlerId);
+	};
+}
+function createJobsDataSurfaceBackgroundQueue(options) {
+	return {
+		unregister: registerDataSurfaceBackgroundActionHandler(options.handlerId, options.execute),
+		async enqueue(job) {
+			if (job.envelope.handlerId !== options.handlerId) throw new Error("Data-surface action envelope handler mismatch");
+			const persisted = await enqueueDataSurfaceActionJob(options, job.envelope);
+			if (!persisted.id) throw new Error("Durable data-surface action job has no ID");
+			return {
+				jobId: persisted.id,
+				details: { queue: persisted.queue }
+			};
+		}
+	};
+}
+async function enqueueDataSurfaceActionJob(options, envelope) {
+	await ObjectRegistry.ensureManifestLoaded("SmrtJob");
+	const jobs = await SmrtJobCollection.create({ db: options.db });
+	const registered = ObjectRegistry.getClassByConstructor(SmrtDataSurfaceActionTask) ?? ObjectRegistry.getClass("SmrtDataSurfaceActionTask");
+	const objectType = registered?.qualifiedName ?? registered?.name ?? SmrtDataSurfaceActionTask.name;
+	return jobs.enqueueJob({
+		tenantId: envelope.principal.tenantId,
+		queue: options.queue ?? "data-surface-actions",
+		objectType,
+		objectId: null,
+		method: "run",
+		args: {
+			version: 1,
+			envelope
+		},
+		priority: options.priority ?? 70,
+		timeout: options.timeout ?? 3e5,
+		maxAttempts: options.maxAttempts ?? 3
+	}, { tenantJobCap: options.tenantJobCap });
+}
+//#endregion
 //#region src/server/serialization.ts
 function serializeResolvedAgent(resolved) {
 	const manifest = resolved.manifest;
@@ -614,6 +787,281 @@ function serializeResolvedAgent(resolved) {
 	};
 }
 //#endregion
-export { InMemoryDataSurfaceActionStateStore, buildRouteMap, createDataSurfaceActionAdapter, extractAgentManifest, extractAgentPackagesFromConfig, isBoundedDataSurfaceJsonValue, loadManifestsFromConfig, loadManifestsFromPackages, loadSlotConfigs, resolveAPIRoute, serializeResolvedAgent };
+//#region src/server/sql-data-surface-action-state.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var TOKEN_TABLE = "_smrt_data_surface_action_tokens";
+var IDEMPOTENCY_TABLE = "_smrt_data_surface_action_idempotency";
+var INTERNAL_SURFACE = {
+	api: false,
+	cli: false,
+	mcp: false
+};
+var DataSurfaceActionTokenState = class extends SmrtObject {
+	tokenHash = "";
+	record = emptyTokenRecord();
+	consumedBy = null;
+};
+__decorateClass([field({
+	type: "text",
+	required: true,
+	unique: true
+})], DataSurfaceActionTokenState.prototype, "tokenHash", 2);
+__decorateClass([field({
+	type: "json",
+	required: true
+})], DataSurfaceActionTokenState.prototype, "record", 2);
+__decorateClass([field({
+	type: "text",
+	nullable: true
+})], DataSurfaceActionTokenState.prototype, "consumedBy", 2);
+DataSurfaceActionTokenState = __decorateClass([smrt({
+	tableName: "_smrt_data_surface_action_tokens",
+	...INTERNAL_SURFACE
+})], DataSurfaceActionTokenState);
+var DataSurfaceActionIdempotencyState = class extends SmrtObject {
+	keyHash = "";
+	status = "reserved";
+	requestFingerprint = "";
+	ownerHash = null;
+	reservedAt = null;
+	result = null;
+	recovery = null;
+};
+__decorateClass([field({
+	type: "text",
+	required: true,
+	unique: true
+})], DataSurfaceActionIdempotencyState.prototype, "keyHash", 2);
+__decorateClass([field({
+	type: "text",
+	required: true
+})], DataSurfaceActionIdempotencyState.prototype, "status", 2);
+__decorateClass([field({
+	type: "text",
+	required: true
+})], DataSurfaceActionIdempotencyState.prototype, "requestFingerprint", 2);
+__decorateClass([field({
+	type: "text",
+	nullable: true
+})], DataSurfaceActionIdempotencyState.prototype, "ownerHash", 2);
+__decorateClass([field({
+	type: "text",
+	nullable: true
+})], DataSurfaceActionIdempotencyState.prototype, "reservedAt", 2);
+__decorateClass([field({
+	type: "json",
+	nullable: true
+})], DataSurfaceActionIdempotencyState.prototype, "result", 2);
+__decorateClass([field({
+	type: "json",
+	nullable: true
+})], DataSurfaceActionIdempotencyState.prototype, "recovery", 2);
+DataSurfaceActionIdempotencyState = __decorateClass([smrt({
+	tableName: "_smrt_data_surface_action_idempotency",
+	...INTERNAL_SURFACE
+})], DataSurfaceActionIdempotencyState);
+var DataSurfaceActionStateCorruptionError = class extends Error {
+	constructor(table) {
+		super(`Malformed durable data-surface action state in ${table}`);
+		this.name = "DataSurfaceActionStateCorruptionError";
+	}
+};
+var SqlDataSurfaceActionStateStore = class {
+	db;
+	now;
+	authorizeRecovery;
+	constructor(options) {
+		this.db = options.db;
+		this.now = options.now ?? Date.now;
+		this.authorizeRecovery = options.authorizeRecovery;
+	}
+	async putToken(token, record) {
+		const timestamp = new Date(this.now()).toISOString();
+		await this.db.query(`INSERT INTO ${TOKEN_TABLE}
+        (id, slug, context, created_at, updated_at, token_hash, record, consumed_by)
+       VALUES (?, ?, '', ?, ?, ?, ?, NULL)
+       ON CONFLICT(token_hash) DO NOTHING`, randomUUID(), `action-token-${randomUUID()}`, timestamp, timestamp, secretHash(token), JSON.stringify(record));
+	}
+	async getToken(token) {
+		const row = (await this.db.query(`SELECT record, consumed_by FROM ${TOKEN_TABLE} WHERE token_hash = ? LIMIT 1`, secretHash(token))).rows[0];
+		if (!row) return void 0;
+		return {
+			...tokenRecord(parseObject(row.record, TOKEN_TABLE)),
+			...typeof row.consumed_by === "string" ? { consumedBy: row.consumed_by } : {}
+		};
+	}
+	async markTokenConsumed(token, idempotencyKey) {
+		return (await this.db.query(`UPDATE ${TOKEN_TABLE}
+          SET consumed_by = ?, updated_at = ?
+        WHERE token_hash = ? AND consumed_by IS NULL
+        RETURNING token_hash`, secretHash(idempotencyKey), new Date(this.now()).toISOString(), secretHash(token))).rows.length === 1;
+	}
+	async consumeTokenAndReserveIdempotency(token, idempotencyKey, scope, reservation) {
+		const transaction = this.db.transaction;
+		if (!transaction) throw new Error("Durable data-surface action state requires database transactions");
+		return await transaction.call(this.db, async (tx) => {
+			const timestamp = new Date(this.now()).toISOString();
+			if ((await tx.query(`UPDATE ${TOKEN_TABLE}
+            SET consumed_by = ?, updated_at = ?
+          WHERE token_hash = ?
+            AND (consumed_by IS NULL OR consumed_by = ?)
+          RETURNING token_hash`, secretHash(idempotencyKey), timestamp, secretHash(token), secretHash(idempotencyKey))).rows.length !== 1) return void 0;
+			await tx.query(`INSERT INTO ${IDEMPOTENCY_TABLE}
+          (id, slug, context, created_at, updated_at, key_hash, status,
+           request_fingerprint, owner_hash, reserved_at, result, recovery)
+         VALUES (?, ?, '', ?, ?, ?, 'reserved', ?, ?, ?, NULL, NULL)
+         ON CONFLICT(key_hash) DO NOTHING`, randomUUID(), `action-idempotency-${randomUUID()}`, timestamp, timestamp, secretHash(scope), reservation.requestFingerprint, secretHash(reservation.ownerToken), String(reservation.reservedAt));
+			const current = await this.getIdempotencyWithOwner(scope, reservation.ownerToken, tx);
+			if (!current) throw new DataSurfaceActionStateCorruptionError(IDEMPOTENCY_TABLE);
+			return current;
+		});
+	}
+	async getIdempotency(key) {
+		const row = (await this.db.query(`SELECT status, request_fingerprint, owner_hash, reserved_at, result, recovery
+         FROM ${IDEMPOTENCY_TABLE} WHERE key_hash = ? LIMIT 1`, secretHash(key))).rows[0];
+		return row ? idempotencyRecord(row) : void 0;
+	}
+	async reserveIdempotency(key, reservation) {
+		const timestamp = new Date(this.now()).toISOString();
+		await this.db.query(`INSERT INTO ${IDEMPOTENCY_TABLE}
+        (id, slug, context, created_at, updated_at, key_hash, status,
+         request_fingerprint, owner_hash, reserved_at, result, recovery)
+       VALUES (?, ?, '', ?, ?, ?, 'reserved', ?, ?, ?, NULL, NULL)
+       ON CONFLICT(key_hash) DO NOTHING`, randomUUID(), `action-idempotency-${randomUUID()}`, timestamp, timestamp, secretHash(key), reservation.requestFingerprint, secretHash(reservation.ownerToken), String(reservation.reservedAt));
+		const current = await this.getIdempotencyWithOwner(key, reservation.ownerToken);
+		if (!current) throw new DataSurfaceActionStateCorruptionError(IDEMPOTENCY_TABLE);
+		return current;
+	}
+	async completeIdempotency(key, ownerToken, result) {
+		return (await this.db.query(`UPDATE ${IDEMPOTENCY_TABLE}
+          SET status = 'completed', result = ?, owner_hash = NULL,
+              reserved_at = NULL, updated_at = ?
+        WHERE key_hash = ? AND status = 'reserved' AND owner_hash = ?
+        RETURNING key_hash`, JSON.stringify(result), new Date(this.now()).toISOString(), secretHash(key), secretHash(ownerToken))).rows.length === 1;
+	}
+	async releaseIdempotency(key, ownerToken) {
+		return (await this.db.query(`DELETE FROM ${IDEMPOTENCY_TABLE}
+        WHERE key_hash = ? AND status = 'reserved' AND owner_hash = ?
+        RETURNING key_hash`, secretHash(key), secretHash(ownerToken))).rows.length === 1;
+	}
+	async reconcileIdempotency(key, request) {
+		if (!request.requestFingerprint || !Number.isSafeInteger(request.reservedAt) || request.reservedAt < 0 || !request.authorizedBy || request.authorizedBy.length > 256 || !request.evidence || request.evidence.length > 2048) return false;
+		if (!this.authorizeRecovery || !await this.authorizeRecovery(Object.freeze({ ...request }))) return false;
+		const recovery = {
+			authorizedBy: request.authorizedBy,
+			evidence: request.evidence,
+			reconciledAt: this.now()
+		};
+		return (await this.db.query(`UPDATE ${IDEMPOTENCY_TABLE}
+          SET status = 'completed', result = ?, recovery = ?, owner_hash = NULL,
+              reserved_at = NULL, updated_at = ?
+        WHERE key_hash = ? AND status = 'reserved'
+          AND request_fingerprint = ? AND reserved_at = ?
+        RETURNING key_hash`, JSON.stringify(request.result), JSON.stringify(recovery), new Date(recovery.reconciledAt).toISOString(), secretHash(key), request.requestFingerprint, String(request.reservedAt))).rows.length === 1;
+	}
+	async getIdempotencyWithOwner(key, ownerToken, db = this.db) {
+		const row = (await db.query(`SELECT status, request_fingerprint, owner_hash, reserved_at, result, recovery
+         FROM ${IDEMPOTENCY_TABLE} WHERE key_hash = ? LIMIT 1`, secretHash(key))).rows[0];
+		if (!row) return void 0;
+		const record = idempotencyRecord(row);
+		if (record.status === "reserved" && row.owner_hash === secretHash(ownerToken)) return {
+			...record,
+			ownerToken
+		};
+		return record;
+	}
+};
+function createSqlDataSurfaceActionStateStore(options) {
+	return new SqlDataSurfaceActionStateStore(options);
+}
+function secretHash(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function parseObject(value, table) {
+	let parsed = value;
+	if (typeof value === "string") try {
+		parsed = JSON.parse(value);
+	} catch {
+		throw new DataSurfaceActionStateCorruptionError(table);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new DataSurfaceActionStateCorruptionError(table);
+	return parsed;
+}
+function idempotencyRecord(row) {
+	const requestFingerprint = row.request_fingerprint;
+	if (typeof requestFingerprint !== "string") throw new DataSurfaceActionStateCorruptionError(IDEMPOTENCY_TABLE);
+	if (row.status === "reserved") {
+		const reservedAt = Number(row.reserved_at);
+		if (typeof row.owner_hash !== "string" || !Number.isSafeInteger(reservedAt)) throw new DataSurfaceActionStateCorruptionError(IDEMPOTENCY_TABLE);
+		return {
+			status: "reserved",
+			requestFingerprint,
+			ownerToken: "",
+			reservedAt
+		};
+	}
+	if (row.status !== "completed") throw new DataSurfaceActionStateCorruptionError(IDEMPOTENCY_TABLE);
+	const result = actionResult(parseObject(row.result, IDEMPOTENCY_TABLE));
+	const recovery = row.recovery == null ? void 0 : recoveryEvidence(parseObject(row.recovery, IDEMPOTENCY_TABLE));
+	return {
+		status: "completed",
+		requestFingerprint,
+		result,
+		...recovery ? { recovery } : {}
+	};
+}
+function tokenRecord(value) {
+	if (!Number.isSafeInteger(value.expiresAt) || !Number.isSafeInteger(value.revision) || [
+		"actorUserId",
+		"identityKey",
+		"actionId",
+		"actionFingerprint",
+		"queryFingerprint",
+		"selectionFingerprint",
+		"resolvedRowsFingerprint",
+		"requestFingerprint"
+	].some((key) => typeof value[key] !== "string") || ![
+		"tenantId",
+		"onBehalfOfUserId",
+		"actsAsProfileId",
+		"agentClass"
+	].every((key) => value[key] === null || typeof value[key] === "string")) throw new DataSurfaceActionStateCorruptionError(TOKEN_TABLE);
+	return value;
+}
+function actionResult(value) {
+	if (value.version !== 1 || typeof value.requestId !== "string" || typeof value.actionId !== "string" || value.phase !== "apply" || typeof value.ok !== "boolean" || !value.identity || typeof value.identity !== "object" || Array.isArray(value.identity) || value.reason !== void 0 && typeof value.reason !== "string") throw new DataSurfaceActionStateCorruptionError(IDEMPOTENCY_TABLE);
+	return value;
+}
+function recoveryEvidence(value) {
+	if (typeof value.authorizedBy !== "string" || typeof value.evidence !== "string" || !Number.isSafeInteger(value.reconciledAt)) throw new DataSurfaceActionStateCorruptionError(IDEMPOTENCY_TABLE);
+	return value;
+}
+function emptyTokenRecord() {
+	return {
+		expiresAt: 0,
+		actorUserId: "",
+		tenantId: null,
+		onBehalfOfUserId: null,
+		actsAsProfileId: null,
+		agentClass: null,
+		identityKey: "",
+		actionId: "",
+		actionFingerprint: "",
+		revision: 0,
+		queryFingerprint: "",
+		selectionFingerprint: "",
+		resolvedRowsFingerprint: "",
+		requestFingerprint: ""
+	};
+}
+//#endregion
+export { DataSurfaceActionIdempotencyState, DataSurfaceActionStateCorruptionError, DataSurfaceActionTokenState, InMemoryDataSurfaceActionStateStore, SmrtDataSurfaceActionTask, SqlDataSurfaceActionStateStore, buildRouteMap, createDataSurfaceActionAdapter, createJobsDataSurfaceBackgroundQueue, createSqlDataSurfaceActionStateStore, extractAgentManifest, extractAgentPackagesFromConfig, isBoundedDataSurfaceJsonValue, loadManifestsFromConfig, loadManifestsFromPackages, loadSlotConfigs, registerDataSurfaceBackgroundActionHandler, resolveAPIRoute, serializeResolvedAgent };
 
 //# sourceMappingURL=server.js.map