rivetkit 2.1.5 → 2.1.6-rc.1

package/src/drivers/engine/config.ts

@@ -1,9 +1,5 @@
 import { z } from "zod/v4";
-import {
-	ClientConfigSchemaBase,
-	transformClientConfig,
-} from "@/client/config";
-import { getRivetRunnerKey } from "@/utils/env-vars";
+import { ClientConfigSchemaBase, transformClientConfig } from "@/client/config";
 
 /**
  * Base engine config schema without transforms so it can be merged in to other schemas.
@@ -11,11 +7,10 @@ import { getRivetRunnerKey } from "@/utils/env-vars";
  * We include the client config since this includes the common properties like endpoint, namespace, etc.
  */
 export const EngineConfigSchemaBase = ClientConfigSchemaBase.extend({
-	/** Unique key for this runner. Runners connecting a given key will replace any other runner connected with the same key. */
+	/** Deprecated. Unique key for this runner. Runners connecting a given key will replace any other runner connected with the same key. */
 	runnerKey: z
 		.string()
-		.optional()
-		.transform((val) => val ?? getRivetRunnerKey()),
+		.optional(),
 
 	/** How many actors this runner can run. */
 	totalSlots: z.number().default(100_000),
@@ -36,8 +31,5 @@ export function transformEngineConfig(
 	config: z.infer<typeof EngineConfigSchemaBase>,
 	ctx: z.RefinementCtx,
 ) {
-	return {
-		...transformClientConfig(config, ctx),
-		runnerKey: config.runnerKey,
-	};
+	return transformClientConfig(config, ctx);
 }

package/src/drivers/engine/mod.ts

@@ -25,11 +25,7 @@ export function createEngineDriver(): DriverConfig {
 			managerDriver: ManagerDriver,
 			inlineClient: Client<any>,
 		) => {
-			return new EngineActorDriver(
-				config,
-				managerDriver,
-				inlineClient,
-			);
+			return new EngineActorDriver(config, managerDriver, inlineClient);
 		},
 		autoStartActorDriver: true,
 	};

package/src/drivers/file-system/actor.ts

@@ -1,12 +1,12 @@
 import type { AnyClient } from "@/client/client";
 import type { RawDatabaseClient } from "@/db/config";
-import type { SqliteVfs } from "@rivetkit/sqlite-vfs";
+import type { ISqliteVfs } from "@rivetkit/sqlite-vfs";
 import {
-	importSqliteVfs,
 	type ActorDriver,
 	type AnyActorInstance,
 	type ManagerDriver,
 } from "@/driver-helpers/mod";
+import { SqliteVfsPoolManager } from "@/driver-helpers/sqlite-pool";
 import type { FileSystemGlobalState } from "./global-state";
 import { RegistryConfig } from "@/registry/config";
 
@@ -20,6 +20,8 @@ export class FileSystemActorDriver implements ActorDriver {
 	#managerDriver: ManagerDriver;
 	#inlineClient: AnyClient;
 	#state: FileSystemGlobalState;
+	#sqlitePool: SqliteVfsPoolManager;
+	startSleep?: (actorId: string) => void;
 
 	constructor(
 		config: RegistryConfig,
@@ -31,6 +33,16 @@ export class FileSystemActorDriver implements ActorDriver {
 		this.#managerDriver = managerDriver;
 		this.#inlineClient = inlineClient;
 		this.#state = state;
+		this.#sqlitePool = new SqliteVfsPoolManager(config);
+
+		if (this.#state.persist) {
+			// Only define startSleep when persistence is enabled. The actor runtime
+			// checks for this property to determine whether the driver supports sleep.
+			this.startSleep = (actorId: string) => {
+				// Spawns the sleepActor promise.
+				this.#state.sleepActor(actorId);
+			};
+		}
 	}
 
 	async loadActor(actorId: string): Promise<AnyActorInstance> {
@@ -71,11 +83,35 @@ export class FileSystemActorDriver implements ActorDriver {
 		await this.#state.kvBatchDelete(actorId, keys);
 	}
 
+	async kvDeleteRange(
+		actorId: string,
+		start: Uint8Array,
+		end: Uint8Array,
+	): Promise<void> {
+		await this.#state.kvDeleteRange(actorId, start, end);
+	}
+
 	async kvListPrefix(
 		actorId: string,
 		prefix: Uint8Array,
+		options?: {
+			reverse?: boolean;
+			limit?: number;
+		},
+	): Promise<[Uint8Array, Uint8Array][]> {
+		return await this.#state.kvListPrefix(actorId, prefix, options);
+	}
+
+	async kvListRange(
+		actorId: string,
+		start: Uint8Array,
+		end: Uint8Array,
+		options?: {
+			reverse?: boolean;
+			limit?: number;
+		},
 	): Promise<[Uint8Array, Uint8Array][]> {
-		return await this.#state.kvListPrefix(actorId, prefix);
+		return await this.#state.kvListRange(actorId, start, end, options);
 	}
 
 	async setAlarm(actor: AnyActorInstance, timestamp: number): Promise<void> {
@@ -83,13 +119,12 @@ export class FileSystemActorDriver implements ActorDriver {
 	}
 
 	/** Creates a SQLite VFS instance for creating KV-backed databases */
-	async createSqliteVfs(): Promise<SqliteVfs> {
-		return await importSqliteVfs();
+	async createSqliteVfs(actorId: string): Promise<ISqliteVfs> {
+		return await this.#sqlitePool.acquire(actorId);
 	}
 
-	startSleep(actorId: string): void {
-		// Spawns the sleepActor promise
-		this.#state.sleepActor(actorId);
+	async shutdownRunner(_immediate: boolean): Promise<void> {
+		await this.#sqlitePool.shutdown();
 	}
 
 	async startDestroy(actorId: string): Promise<void> {

package/src/drivers/file-system/global-state.ts

@@ -44,8 +44,20 @@ import {
 	validateKvKeys,
 } from "./kv-limits";
 
+const DEFAULT_LIST_LIMIT = 16_384;
+
 // Actor handler to track running instances
 
+function compareBytes(a: Uint8Array, b: Uint8Array): number {
+	const len = Math.min(a.length, b.length);
+	for (let i = 0; i < len; i++) {
+		if (a[i] !== b[i]) {
+			return a[i] - b[i];
+		}
+	}
+	return a.length - b.length;
+}
+
 enum ActorLifecycleState {
 	NONEXISTENT, // Entry exists but actor not yet created
 	AWAKE, // Actor is running normally
@@ -563,36 +575,36 @@ export class FileSystemGlobalState {
 				entry.generation = crypto.randomUUID();
 			}
 
-				// Initialize storage (runtime KV is stored in SQLite; state.kvStorage is legacy-only)
-				const initialKvState = getInitialActorKvState(input);
+			// Initialize storage (runtime KV is stored in SQLite; state.kvStorage is legacy-only)
+			const initialKvState = getInitialActorKvState(input);
 
-				await this.#withActorWrite(actorId, async (lockedEntry) => {
-					lockedEntry.state = {
+			await this.#withActorWrite(actorId, async (lockedEntry) => {
+				lockedEntry.state = {
+					actorId,
+					name,
+					key: key as readonly string[],
+					createdAt: BigInt(Date.now()),
+					kvStorage: [],
+					startTs: null,
+					connectableTs: null,
+					sleepTs: null,
+					destroyTs: null,
+				};
+				if (this.#persist) {
+					await this.#performWrite(
 						actorId,
-						name,
-						key: key as readonly string[],
-						createdAt: BigInt(Date.now()),
-						kvStorage: [],
-						startTs: null,
-						connectableTs: null,
-						sleepTs: null,
-						destroyTs: null,
-					};
-					if (this.#persist) {
-						await this.#performWrite(
-							actorId,
-							lockedEntry.generation,
-							lockedEntry.state,
-						);
-					}
-					if (initialKvState.length > 0) {
-						const db = this.#getOrCreateActorKvDatabase(actorId);
-						this.#putKvEntriesInDb(db, initialKvState);
-					}
-				});
-			}
-			return entry;
+						lockedEntry.generation,
+						lockedEntry.state,
+					);
+				}
+				if (initialKvState.length > 0) {
+					const db = this.#getOrCreateActorKvDatabase(actorId);
+					this.#putKvEntriesInDb(db, initialKvState);
+				}
+			});
 		}
+		return entry;
+	}
 
 	async sleepActor(actorId: string) {
 		invariant(
@@ -609,7 +621,12 @@ export class FileSystemGlobalState {
 			return;
 		}
 		actor.lifecycleState = ActorLifecycleState.STARTING_SLEEP;
-		actor.stopPromise = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled actor sleep stop promise rejection", reason }));
+		actor.stopPromise = promiseWithResolvers((reason) =>
+			logger().warn({
+				msg: "unhandled actor sleep stop promise rejection",
+				reason,
+			}),
+		);
 
 		// Wait for actor to fully start before stopping it to avoid race conditions
 		if (actor.loadPromise) await actor.loadPromise.catch();
@@ -640,12 +657,12 @@ export class FileSystemGlobalState {
 			// Stop actor
 			invariant(actor.actor, "actor should be loaded");
 			await actor.actor.onStop("sleep");
-			} finally {
-				// Ensure any pending KV writes finish before removing the entry.
-				await this.#withActorWrite(actorId, async () => {});
-				this.#closeActorKvDatabase(actorId);
-				actor.stopPromise?.resolve();
-				actor.stopPromise = undefined;
+		} finally {
+			// Ensure any pending KV writes finish before removing the entry.
+			await this.#withActorWrite(actorId, async () => { });
+			this.#closeActorKvDatabase(actorId);
+			actor.stopPromise?.resolve();
+			actor.stopPromise = undefined;
 
 			// Remove from map after stop is complete
 			this.#actors.delete(actorId);
@@ -662,7 +679,12 @@ export class FileSystemGlobalState {
 			return;
 		}
 		actor.lifecycleState = ActorLifecycleState.STARTING_DESTROY;
-		actor.stopPromise = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled actor destroy stop promise rejection", reason }));
+		actor.stopPromise = promiseWithResolvers((reason) =>
+			logger().warn({
+				msg: "unhandled actor destroy stop promise rejection",
+				reason,
+			}),
+		);
 
 		// Wait for actor to fully start before stopping it to avoid race conditions
 		if (actor.loadPromise) await actor.loadPromise.catch();
@@ -695,9 +717,9 @@ export class FileSystemGlobalState {
 				await actor.actor.onStop("destroy");
 			}
 
-				// Ensure any pending KV writes finish before deleting files.
-				await this.#withActorWrite(actorId, async () => {});
-				this.#closeActorKvDatabase(actorId);
+			// Ensure any pending KV writes finish before deleting files.
+			await this.#withActorWrite(actorId, async () => { });
+			this.#closeActorKvDatabase(actorId);
 
 			// Clear alarm timeout if exists
 			if (actor.alarmTimeout) {
@@ -756,7 +778,7 @@ export class FileSystemGlobalState {
 			}
 		} finally {
 			// Ensure any pending KV writes finish before clearing the entry.
-			await this.#withActorWrite(actorId, async () => {});
+			await this.#withActorWrite(actorId, async () => { });
 			actor.stopPromise?.resolve();
 			actor.stopPromise = undefined;
 
@@ -835,7 +857,12 @@ export class FileSystemGlobalState {
 		invariant(entry, "actor entry does not exist");
 
 		const previousWrite = entry.pendingWriteResolver;
-		const currentWrite = promiseWithResolvers<void>((reason) => logger().warn({ msg: "unhandled kv write promise rejection", reason }));
+		const currentWrite = promiseWithResolvers<void>((reason) =>
+			logger().warn({
+				msg: "unhandled kv write promise rejection",
+				reason,
+			}),
+		);
 		entry.pendingWriteResolver = currentWrite;
 
 		if (previousWrite) {
@@ -920,7 +947,7 @@ export class FileSystemGlobalState {
 				try {
 					const fs = getNodeFs();
 					await fs.unlink(tempPath);
-				} catch {}
+				} catch { }
 				logger().error({
 					msg: "failed to write alarm",
 					actorId,
@@ -1072,7 +1099,12 @@ export class FileSystemGlobalState {
 		}
 
 		// Create start promise
-		entry.startPromise = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled actor start promise rejection", reason }));
+		entry.startPromise = promiseWithResolvers((reason) =>
+			logger().warn({
+				msg: "unhandled actor start promise rejection",
+				reason,
+			}),
+		);
 
 		try {
 			// Create actor
@@ -1105,25 +1137,25 @@ export class FileSystemGlobalState {
 					connectableTs: now,
 					sleepTs: null, // Clear sleep timestamp when actor wakes up
 				};
-					if (this.#persist) {
-						await this.#performWrite(
-							actorId,
-							lockedEntry.generation,
-							lockedEntry.state,
-						);
-					}
-				});
+				if (this.#persist) {
+					await this.#performWrite(
+						actorId,
+						lockedEntry.generation,
+						lockedEntry.state,
+					);
+				}
+			});
 
 			// Finish
 			entry.startPromise.resolve();
 			entry.startPromise = undefined;
 
 			return entry.actor;
-			} catch (innerError) {
-				const error = new Error(
-					`Failed to start actor ${actorId}: ${innerError}`,
-					{ cause: innerError },
-				);
+		} catch (innerError) {
+			const error = new Error(
+				`Failed to start actor ${actorId}: ${innerError}`,
+				{ cause: innerError },
+			);
 			entry.startPromise?.reject(error);
 			entry.startPromise = undefined;
 			throw error;
@@ -1407,12 +1439,44 @@ export class FileSystemGlobalState {
 		});
 	}
 
+	/**
+	 * Delete KV entries in the half-open range [start, end).
+	 */
+	async kvDeleteRange(
+		actorId: string,
+		start: Uint8Array,
+		end: Uint8Array,
+	): Promise<void> {
+		await this.loadActor(actorId);
+		await this.#withActorWrite(actorId, async (entry) => {
+			if (!entry.state) {
+				if (this.isActorStopping(actorId)) {
+					return;
+				}
+				throw new Error(`Actor ${actorId} state not loaded`);
+			}
+
+			validateKvKey(start, "start key");
+			validateKvKey(end, "end key");
+			if (compareBytes(start, end) >= 0) {
+				return;
+			}
+
+			const db = this.#getOrCreateActorKvDatabase(actorId);
+			db.run("DELETE FROM kv WHERE key >= ? AND key < ?", [start, end]);
+		});
+	}
+
 	/**
 	 * List KV entries with a given prefix for an actor.
 	 */
 	async kvListPrefix(
 		actorId: string,
 		prefix: Uint8Array,
+		options?: {
+			reverse?: boolean;
+			limit?: number;
+		},
 	): Promise<[Uint8Array, Uint8Array][]> {
 		const entry = await this.loadActor(actorId);
 		await this.#waitForPendingWrite(actorId);
@@ -1427,19 +1491,71 @@ export class FileSystemGlobalState {
 
 		const db = this.#getOrCreateActorKvDatabase(actorId);
 		const upperBound = computePrefixUpperBound(prefix);
+		const direction = options?.reverse ? "DESC" : "ASC";
+		const limit = options?.limit ?? DEFAULT_LIST_LIMIT;
 		const rows = upperBound
-			? db.all<{ key: Uint8Array | ArrayBuffer; value: Uint8Array | ArrayBuffer }>(
-					"SELECT key, value FROM kv WHERE key >= ? AND key < ? ORDER BY key ASC",
-					[prefix, upperBound],
-				)
-			: db.all<{ key: Uint8Array | ArrayBuffer; value: Uint8Array | ArrayBuffer }>(
-					"SELECT key, value FROM kv WHERE key >= ? ORDER BY key ASC",
-					[prefix],
-				);
+			? db.all<{
+				key: Uint8Array | ArrayBuffer;
+				value: Uint8Array | ArrayBuffer;
+			}>(
+				`SELECT key, value FROM kv WHERE key >= ? AND key < ? ORDER BY key ${direction} LIMIT ?`,
+				[prefix, upperBound, limit],
+			)
+			: db.all<{
+				key: Uint8Array | ArrayBuffer;
+				value: Uint8Array | ArrayBuffer;
+			}>(
+				`SELECT key, value FROM kv WHERE key >= ? ORDER BY key ${direction} LIMIT ?`,
+				[prefix, limit],
+			);
 
 		return rows.map((row) => [
 			ensureUint8Array(row.key, "key"),
 			ensureUint8Array(row.value, "value"),
 		]);
 	}
-}
+
+	/**
+	 * List KV entries in the half-open range [start, end).
+	 */
+	async kvListRange(
+		actorId: string,
+		start: Uint8Array,
+		end: Uint8Array,
+		options?: {
+			reverse?: boolean;
+			limit?: number;
+		},
+	): Promise<[Uint8Array, Uint8Array][]> {
+		const entry = await this.loadActor(actorId);
+		await this.#waitForPendingWrite(actorId);
+		if (!entry.state) {
+			if (this.isActorStopping(actorId)) {
+				throw new Error(`Actor ${actorId} is destroying`);
+			} else {
+				throw new Error(`Actor ${actorId} state not loaded`);
+			}
+		}
+		validateKvKey(start, "start key");
+		validateKvKey(end, "end key");
+		if (compareBytes(start, end) >= 0) {
+			return [];
+		}
+
+		const db = this.#getOrCreateActorKvDatabase(actorId);
+		const direction = options?.reverse ? "DESC" : "ASC";
+		const limit = options?.limit ?? DEFAULT_LIST_LIMIT;
+		const rows = db.all<{
+			key: Uint8Array | ArrayBuffer;
+			value: Uint8Array | ArrayBuffer;
+		}>(
+			`SELECT key, value FROM kv WHERE key >= ? AND key < ? ORDER BY key ${direction} LIMIT ?`,
+			[start, end, limit],
+		);
+
+		return rows.map((row) => [
+			ensureUint8Array(row.key, "key"),
+			ensureUint8Array(row.value, "value"),
+		]);
+	}
+}

package/src/drivers/file-system/kv-limits.ts

@@ -17,7 +17,7 @@ export function estimateKvSize(db: SqliteRuntimeDatabase): number {
 
 export function validateKvKey(
 	key: Uint8Array,
-	keyLabel: "key" | "prefix key" = "key",
+	keyLabel: "key" | "prefix key" | "start key" | "end key" = "key",
 ): void {
 	if (key.byteLength + KV_KEY_WRAPPER_OVERHEAD_SIZE > KV_MAX_KEY_SIZE) {
 		throw new Error(`${keyLabel} is too long (max 2048 bytes)`);

package/src/drivers/file-system/sqlite-runtime.ts

@@ -110,7 +110,10 @@ export function loadSqliteRuntime(): SqliteRuntime {
 					const rawDb = new BunDatabase(path);
 					configureSqliteRuntimeDatabase(rawDb, path);
 					const query = rawDb.query?.bind(rawDb);
-					if (!query) throw new Error("bun:sqlite database missing query method");
+					if (!query)
+						throw new Error(
+							"bun:sqlite database missing query method",
+						);
 					return createPreparedDatabaseAdapter(rawDb, query);
 				},
 			};
@@ -120,7 +123,9 @@ export function loadSqliteRuntime(): SqliteRuntime {
 	}
 
 	try {
-		const nodeSqlite = requireFn(/* webpackIgnore: true */ "node:sqlite") as {
+		const nodeSqlite = requireFn(
+			/* webpackIgnore: true */ "node:sqlite",
+		) as {
 			DatabaseSync?: SqliteDatabaseCtor;
 		};
 		const NodeDatabaseSync = nodeSqlite.DatabaseSync;
@@ -132,7 +137,9 @@ export function loadSqliteRuntime(): SqliteRuntime {
 					configureSqliteRuntimeDatabase(rawDb, path);
 					const prepare = rawDb.prepare?.bind(rawDb);
 					if (!prepare) {
-						throw new Error("node:sqlite DatabaseSync missing prepare method");
+						throw new Error(
+							"node:sqlite DatabaseSync missing prepare method",
+						);
 					}
 					return createPreparedDatabaseAdapter(rawDb, prepare);
 				},
@@ -158,7 +165,9 @@ export function loadSqliteRuntime(): SqliteRuntime {
 					configureSqliteRuntimeDatabase(rawDb, path);
 					const prepare = rawDb.prepare?.bind(rawDb);
 					if (!prepare) {
-						throw new Error("better-sqlite3 database missing prepare method");
+						throw new Error(
+							"better-sqlite3 database missing prepare method",
+						);
 					}
 					return createPreparedDatabaseAdapter(rawDb, prepare);
 				},

package/src/engine-process/mod.ts

@@ -166,7 +166,11 @@ export async function ensureEngineProcess(
 				issues: "https://github.com/rivet-dev/rivetkit/issues",
 				support: "https://rivet.dev/discord",
 			});
-		} else if (stderrOutput.includes("Rivet Engine has been rolled back to a previous version")) {
+		} else if (
+			stderrOutput.includes(
+				"Rivet Engine has been rolled back to a previous version",
+			)
+		) {
 			logger().error({
 				msg: "rivet engine version downgrade detected",
 				hint: `You attempted to downgrade the RivetKit version in development. To fix this, nuke the database by running: '${binaryPath}' database nuke --yes`,

package/src/inspector/actor-inspector.ts

@@ -11,6 +11,7 @@ import * as actorErrors from "@/actor/errors";
 import type { AnyActorInstance } from "@/mod";
 import type * as schema from "@/schemas/actor-inspector/mod";
 import { bufferToArrayBuffer } from "@/utils";
+import { serializeWorkflowHistoryForJson } from "./workflow-history-json";
 
 interface ActorInspectorEmitterEvents {
 	stateUpdated: (state: unknown) => void;
@@ -23,7 +24,6 @@ export type Connection = Omit<schema.Connection, "details"> & {
 	details: unknown;
 };
 
-
 /**
  * Provides a unified interface for inspecting actor external and internal state.
  */
@@ -57,9 +57,7 @@ export class ActorInspector {
 		const maxSize = this.actor.config.options.maxQueueSize;
 		const safeLimit = Math.max(0, Math.floor(limit));
 		const messages = await this.actor.queueManager.getMessages();
-		const sorted = messages.sort(
-			(a, b) => a.createdAt - b.createdAt,
-		);
+		const sorted = messages.sort((a, b) => a.createdAt - b.createdAt);
 		const limited = safeLimit > 0 ? sorted.slice(0, safeLimit) : [];
 		return {
 			size: BigInt(this.#lastQueueSize),
@@ -111,25 +109,23 @@ export class ActorInspector {
 		const db = this.actor.db;
 
 		// Get table list from sqlite_master, excluding internal tables.
-		const tables = await db.execute(
+		const tables = (await db.execute(
 			"SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle_%'",
-		) as { name: string; type: string }[];
+		)) as { name: string; type: string }[];
 
 		// Serialize all queries to avoid concurrent @rivetkit/sqlite access
 		// which can cause "file is not a database" errors.
 		const tableInfos = [];
 		for (const table of tables) {
 			const quoted = `"${escapeDoubleQuotes(table.name)}"`;
-			const sample = await db.execute(
+			const sample = (await db.execute(
 				`SELECT * FROM ${quoted} LIMIT 1`,
-			) as Record<string, unknown>[];
-			const countResult = await db.execute(
+			)) as Record<string, unknown>[];
+			const countResult = (await db.execute(
 				`SELECT COUNT(*) as count FROM ${quoted}`,
-			) as { count: number }[];
+			)) as { count: number }[];
 
-			const columnNames = sample?.[0]
-				? Object.keys(sample[0])
-				: [];
+			const columnNames = sample?.[0] ? Object.keys(sample[0]) : [];
 
 			tableInfos.push({
 				table: { schema: "main", name: table.name, type: table.type },
@@ -263,6 +259,26 @@ export class ActorInspector {
 		await this.actor.stateManager.saveState({ immediate: true });
 	}
 
+	async getDatabaseSchemaJson(): Promise<unknown> {
+		return toHttpJsonCompatible(
+			cbor.decode(Buffer.from(await this.getDatabaseSchema())),
+		);
+	}
+
+	async getDatabaseTableRowsJson(
+		table: string,
+		limit: number,
+		offset: number,
+	): Promise<unknown[]> {
+		return toHttpJsonCompatible(
+			cbor.decode(
+				Buffer.from(
+					await this.getDatabaseTableRows(table, limit, offset),
+				),
+			),
+		) as unknown[];
+	}
+
 	getConnectionsJson(): { id: string; details: unknown }[] {
 		return Array.from(
 			this.actor.connectionManager.connections.entries(),
@@ -314,15 +330,14 @@ export class ActorInspector {
 		return result;
 	}
 
-	getWorkflowHistoryJson(): { history: unknown | null; isWorkflowEnabled: boolean } {
-		const bigIntReplacer = (_key: string, value: unknown) =>
-			typeof value === "bigint" ? Number(value) : value;
-		const history = this.getWorkflowHistory();
-		const safeHistory = history
-			? JSON.parse(JSON.stringify(history, bigIntReplacer))
-			: null;
+	getWorkflowHistoryJson(): {
+		history: unknown | null;
+		isWorkflowEnabled: boolean;
+	} {
 		return {
-			history: safeHistory,
+			history: serializeWorkflowHistoryForJson(
+				this.getWorkflowHistory(),
+			),
 			isWorkflowEnabled: this.isWorkflowEnabled(),
 		};
 	}
@@ -350,3 +365,14 @@ function escapeDoubleQuotes(value: string): string {
 	return value.replace(/"/g, '""');
 }
 
+function toHttpJsonCompatible<T>(value: T): T {
+	return JSON.parse(
+		JSON.stringify(value, (_key, nestedValue) =>
+			typeof nestedValue === "bigint"
+				? Number(nestedValue)
+				: nestedValue instanceof Uint8Array
+					? Array.from(nestedValue)
+					: nestedValue,
+		),
+	) as T;
+}