@rivetkit/engine-runner 2.0.27 → 2.0.29-rc.1

package/src/stringify.ts

@@ -40,8 +40,6 @@ export function stringifyToServerTunnelMessageKind(
 	kind: protocol.ToServerTunnelMessageKind,
 ): string {
 	switch (kind.tag) {
-		case "DeprecatedTunnelAck":
-			return "DeprecatedTunnelAck";
 		case "ToServerResponseStart": {
 			const { status, headers, body, stream } = kind.val;
 			const bodyStr = body === null ? "null" : stringifyArrayBuffer(body);
@@ -82,8 +80,6 @@ export function stringifyToClientTunnelMessageKind(
 	kind: protocol.ToClientTunnelMessageKind,
 ): string {
 	switch (kind.tag) {
-		case "DeprecatedTunnelAck":
-			return "DeprecatedTunnelAck";
 		case "ToClientRequestStart": {
 			const { actorId, method, path, headers, body, stream } = kind.val;
 			const bodyStr = body === null ? "null" : stringifyArrayBuffer(body);
@@ -119,7 +115,7 @@ export function stringifyToClientTunnelMessageKind(
 export function stringifyCommand(command: protocol.Command): string {
 	switch (command.tag) {
 		case "CommandStartActor": {
-			const { actorId, generation, config, hibernatingRequests } =
+			const { config, hibernatingRequests } =
 				command.val;
 			const keyStr = config.key === null ? "null" : `"${config.key}"`;
 			const inputStr =
@@ -130,11 +126,10 @@ export function stringifyCommand(command: protocol.Command): string {
 				hibernatingRequests.length > 0
 					? `[${hibernatingRequests.map((hr) => `{gatewayId: ${idToStr(hr.gatewayId)}, requestId: ${idToStr(hr.requestId)}}`).join(", ")}]`
 					: "[]";
-			return `CommandStartActor{actorId: "${actorId}", generation: ${generation}, config: {name: "${config.name}", key: ${keyStr}, createTs: ${stringifyBigInt(config.createTs)}, input: ${inputStr}}, hibernatingRequests: ${hibernatingRequestsStr}}`;
+			return `CommandStartActor{config: {name: "${config.name}", key: ${keyStr}, createTs: ${stringifyBigInt(config.createTs)}, input: ${inputStr}}, hibernatingRequests: ${hibernatingRequestsStr}}`;
 		}
 		case "CommandStopActor": {
-			const { actorId, generation } = command.val;
-			return `CommandStopActor{actorId: "${actorId}", generation: ${generation}}`;
+			return `CommandStopActor`;
 		}
 	}
 }
@@ -146,7 +141,7 @@ export function stringifyCommand(command: protocol.Command): string {
 export function stringifyCommandWrapper(
 	wrapper: protocol.CommandWrapper,
 ): string {
-	return `CommandWrapper{index: ${stringifyBigInt(wrapper.index)}, inner: ${stringifyCommand(wrapper.inner)}}`;
+	return `CommandWrapper{actorId: "${wrapper.checkpoint.actorId}", generation: "${wrapper.checkpoint.generation}", index: ${stringifyBigInt(wrapper.checkpoint.index)}, inner: ${stringifyCommand(wrapper.inner)}}`;
 }
 
 /**
@@ -156,17 +151,17 @@ export function stringifyCommandWrapper(
 export function stringifyEvent(event: protocol.Event): string {
 	switch (event.tag) {
 		case "EventActorIntent": {
-			const { actorId, generation, intent } = event.val;
+			const { intent } = event.val;
 			const intentStr =
 				intent.tag === "ActorIntentSleep"
 					? "Sleep"
 					: intent.tag === "ActorIntentStop"
 						? "Stop"
 						: "Unknown";
-			return `EventActorIntent{actorId: "${actorId}", generation: ${generation}, intent: ${intentStr}}`;
+			return `EventActorIntent{intent: ${intentStr}}`;
 		}
 		case "EventActorStateUpdate": {
-			const { actorId, generation, state } = event.val;
+			const { state } = event.val;
 			let stateStr: string;
 			if (state.tag === "ActorStateRunning") {
 				stateStr = "Running";
@@ -177,13 +172,13 @@ export function stringifyEvent(event: protocol.Event): string {
 			} else {
 				stateStr = "Unknown";
 			}
-			return `EventActorStateUpdate{actorId: "${actorId}", generation: ${generation}, state: ${stateStr}}`;
+			return `EventActorStateUpdate{state: ${stateStr}}`;
 		}
 		case "EventActorSetAlarm": {
-			const { actorId, generation, alarmTs } = event.val;
+			const { alarmTs } = event.val;
 			const alarmTsStr =
 				alarmTs === null ? "null" : stringifyBigInt(alarmTs);
-			return `EventActorSetAlarm{actorId: "${actorId}", generation: ${generation}, alarmTs: ${alarmTsStr}}`;
+			return `EventActorSetAlarm{alarmTs: ${alarmTsStr}}`;
 		}
 	}
 }
@@ -193,7 +188,7 @@ export function stringifyEvent(event: protocol.Event): string {
  * Handles ArrayBuffers, BigInts, and Maps that can't be JSON.stringified
  */
 export function stringifyEventWrapper(wrapper: protocol.EventWrapper): string {
-	return `EventWrapper{index: ${stringifyBigInt(wrapper.index)}, inner: ${stringifyEvent(wrapper.inner)}}`;
+	return `EventWrapper{actorId: ${wrapper.checkpoint.actorId}, generation: "${wrapper.checkpoint.generation}", index: ${stringifyBigInt(wrapper.checkpoint.index)}, inner: ${stringifyEvent(wrapper.inner)}}`;
 }
 
 /**
@@ -207,34 +202,33 @@ export function stringifyToServer(message: protocol.ToServer): string {
 				name,
 				version,
 				totalSlots,
-				lastCommandIdx,
 				prepopulateActorNames,
 				metadata,
 			} = message.val;
-			const lastCommandIdxStr =
-				lastCommandIdx === null
-					? "null"
-					: stringifyBigInt(lastCommandIdx);
 			const prepopulateActorNamesStr =
 				prepopulateActorNames === null
 					? "null"
 					: `Map(${prepopulateActorNames.size})`;
 			const metadataStr = metadata === null ? "null" : `"${metadata}"`;
-			return `ToServerInit{name: "${name}", version: ${version}, totalSlots: ${totalSlots}, lastCommandIdx: ${lastCommandIdxStr}, prepopulateActorNames: ${prepopulateActorNamesStr}, metadata: ${metadataStr}}`;
+			return `ToServerInit{name: "${name}", version: ${version}, totalSlots: ${totalSlots}, prepopulateActorNames: ${prepopulateActorNamesStr}, metadata: ${metadataStr}}`;
 		}
 		case "ToServerEvents": {
 			const events = message.val;
 			return `ToServerEvents{count: ${events.length}, events: [${events.map((e) => stringifyEventWrapper(e)).join(", ")}]}`;
 		}
 		case "ToServerAckCommands": {
-			const { lastCommandIdx } = message.val;
-			return `ToServerAckCommands{lastCommandIdx: ${stringifyBigInt(lastCommandIdx)}}`;
+			const { lastCommandCheckpoints } = message.val;
+			const checkpointsStr =
+				lastCommandCheckpoints.length > 0
+					? `[${lastCommandCheckpoints.map((cp) => `{actorId: "${cp.actorId}", index: ${stringifyBigInt(cp.index)}}`).join(", ")}]`
+					: "[]";
+			return `ToServerAckCommands{lastCommandCheckpoints: ${checkpointsStr}}`;
 		}
 		case "ToServerStopping":
 			return "ToServerStopping";
-		case "ToServerPing": {
+		case "ToServerPong": {
 			const { ts } = message.val;
-			return `ToServerPing{ts: ${stringifyBigInt(ts)}}`;
+			return `ToServerPong{ts: ${stringifyBigInt(ts)}}`;
 		}
 		case "ToServerKvRequest": {
 			const { actorId, requestId, data } = message.val;
@@ -255,19 +249,24 @@ export function stringifyToServer(message: protocol.ToServer): string {
 export function stringifyToClient(message: protocol.ToClient): string {
 	switch (message.tag) {
 		case "ToClientInit": {
-			const { runnerId, lastEventIdx, metadata } = message.val;
+			const { runnerId, metadata } = message.val;
 			const metadataStr = `{runnerLostThreshold: ${stringifyBigInt(metadata.runnerLostThreshold)}}`;
-			return `ToClientInit{runnerId: "${runnerId}", lastEventIdx: ${stringifyBigInt(lastEventIdx)}, metadata: ${metadataStr}}`;
+			return `ToClientInit{runnerId: "${runnerId}", metadata: ${metadataStr}}`;
 		}
-		case "ToClientClose":
-			return "ToClientClose";
+		case "ToClientPing":
+			const { ts } = message.val;
+			return `ToClientPing{ts: ${stringifyBigInt(ts)}}`;
 		case "ToClientCommands": {
 			const commands = message.val;
 			return `ToClientCommands{count: ${commands.length}, commands: [${commands.map((c) => stringifyCommandWrapper(c)).join(", ")}]}`;
 		}
 		case "ToClientAckEvents": {
-			const { lastEventIdx } = message.val;
-			return `ToClientAckEvents{lastEventIdx: ${stringifyBigInt(lastEventIdx)}}`;
+			const { lastEventCheckpoints } = message.val;
+			const checkpointsStr =
+				lastEventCheckpoints.length > 0
+					? `[${lastEventCheckpoints.map((cp) => `{actorId: "${cp.actorId}", index: ${stringifyBigInt(cp.index)}}`).join(", ")}]`
+					: "[]";
+			return `ToClientAckEvents{lastEventCheckpoints: ${checkpointsStr}}`;
 		}
 		case "ToClientKvResponse": {
 			const { requestId, data } = message.val;

package/src/tunnel.ts

@@ -10,12 +10,12 @@ import {
 	stringify as uuidstringify,
 	v4 as uuidv4,
 } from "uuid";
-import type { Runner, RunnerActor } from "./mod";
+import { RunnerShutdownError, type Runner, type RunnerActor } from "./mod";
 import {
 	stringifyToClientTunnelMessageKind,
 	stringifyToServerTunnelMessageKind,
 } from "./stringify";
-import { arraysEqual, idToStr, unreachable } from "./utils";
+import { arraysEqual, idToStr, stringifyError, unreachable } from "./utils";
 import {
 	HIBERNATABLE_SYMBOL,
 	WebSocketTunnelAdapter,
@@ -41,12 +41,6 @@ export interface HibernatingWebSocketMetadata {
 	headers: Record<string, string>;
 }
 
-class RunnerShutdownError extends Error {
-	constructor() {
-		super("Runner shut down");
-	}
-}
-
 export class Tunnel {
 	#runner: Runner;
 
@@ -226,7 +220,7 @@ export class Tunnel {
 						this.log?.error({
 							msg: "error creating websocket during restore",
 							requestId: requestIdStr,
-							err,
+							error: stringifyError(err),
 						});
 
 						// Close the WebSocket on error
@@ -291,7 +285,7 @@ export class Tunnel {
 						this.log?.error({
 							msg: "error creating stale websocket during restore",
 							requestId: requestIdStr,
-							err,
+							error: stringifyError(err),
 						});
 					});
 
@@ -671,9 +665,6 @@ export class Tunnel {
 					message.messageKind.val,
 				);
 				break;
-			case "DeprecatedTunnelAck":
-				// Ignore deprecated tunnel ack messages
-				break;
 			default:
 				unreachable(message.messageKind);
 		}

package/src/utils.ts

@@ -157,3 +157,19 @@ export function idToStr(id: ArrayBuffer): string {
 		.map((byte) => byte.toString(16).padStart(2, "0"))
 		.join("");
 }
+
+export function stringifyError(error: unknown): string {
+	if (error instanceof Error) {
+		return `${error.name}: ${error.message}${error.stack ? `\n${error.stack}` : ""}`;
+	} else if (typeof error === "string") {
+		return error;
+	} else if (typeof error === "object" && error !== null) {
+		try {
+			return `${JSON.stringify(error)}`;
+		} catch {
+			return `[object ${error.constructor?.name || "Object"}]`;
+		}
+	} else {
+		return String(error);
+	}
+}

package/.turbo/turbo-build.log

@@ -1,22 +0,0 @@
-
-> @rivetkit/engine-runner@2.0.27 build /home/runner/work/rivet/rivet/engine/sdks/typescript/runner
-> tsup src/mod.ts
-
-CLI Building entry: src/mod.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.0
-CLI Using tsup config: /home/runner/work/rivet/rivet/engine/sdks/typescript/runner/tsup.config.ts
-CLI Target: node16
-CLI Cleaning output folder
-CJS Build start
-ESM Build start
-DTS Build start
-ESM dist/mod.js     90.59 KB
-ESM dist/mod.js.map 179.70 KB
-ESM ⚡️ Build success in 444ms
-CJS dist/mod.cjs     91.64 KB
-CJS dist/mod.cjs.map 153.67 KB
-CJS ⚡️ Build success in 446ms
-DTS ⚡️ Build success in 1855ms
-DTS dist/mod.d.cts 14.48 KB
-DTS dist/mod.d.ts  14.48 KB

package/benches/actor-lifecycle.bench.ts

@@ -1,190 +0,0 @@
-// import { Bench } from "tinybench";
-// import { Runner } from "@/mod";
-// import type { ActorConfig } from "@/mod";
-// import {
-// 	createActor,
-// 	destroyActor,
-// 	setupBenchmarkRunner,
-// 	createPromiseResolver,
-// 	RIVET_ENDPOINT,
-// } from "./utils.js";
-// import { afterEach } from "node:test";
-//
-// async function runActorLifecycleBenchmark() {
-// 	// Shared state for benchmarks
-// 	let runner: Runner | null = null;
-// 	let namespaceName: string;
-// 	let runnerName: string;
-// 	let createdActors: string[] = [];
-// 	let wakeActorId: string | null = null;
-// 	let stopped: { promise: Promise<void>; resolve: () => void };
-// 	let started: { promise: Promise<void>; resolve: () => void };
-//
-// 	const bench = new Bench({
-// 		time: 1000,
-// 		iterations: 10,
-// 		warmupTime: 0,
-// 		warmupIterations: 0,
-// 		throws: true,
-// 		setup: async (task) => {
-// 			// Setup benchmark runner
-// 			console.log("Setting up benchmark runner...");
-// 			stopped = createPromiseResolver<void>();
-// 			started = createPromiseResolver<void>();
-//
-// 			const setup = await setupBenchmarkRunner(
-// 				"lifecycle",
-// 				5054,
-// 				async (
-// 					_actorId: string,
-// 					_generation: number,
-// 					_config: ActorConfig,
-// 				) => {
-// 					started.resolve();
-// 				},
-// 				async (_actorId: string, _generation: number) => {
-// 					stopped.resolve();
-// 				},
-// 			);
-// 			runner = setup.runner;
-// 			namespaceName = setup.namespaceName;
-// 			runnerName = setup.runnerName;
-//
-// 			console.log(
-// 				`Benchmark setup complete. Namespace: ${namespaceName}, Runner: ${runnerName}`,
-// 			);
-// 		},
-// 		teardown: async () => {
-// 			if (runner) {
-// 				await runner.shutdown(true);
-// 			}
-//
-// 			// Clean up created actors from creation benchmark
-// 			console.log(
-// 				`Cleaning up ${createdActors.length} actors in ${namespaceName}...`,
-// 			);
-// 			const cleanupActor = createdActors;
-// 			createdActors = [];
-// 			wakeActorId = null;
-// 			for (const actorId of cleanupActor) {
-// 				try {
-// 					await destroyActor(namespaceName, actorId);
-// 				} catch (err) {
-// 					console.warn(`Failed to clean up actor ${actorId}:`, err);
-// 				}
-// 			}
-//
-// 			console.log("Benchmark teardown complete!");
-// 		},
-// 	});
-//
-// 	bench.add("create actor", async () => {
-// 		const actorResponse = await createActor(
-// 			namespaceName,
-// 			runnerName,
-// 			false,
-// 		);
-// 		const actorId = actorResponse.actor.actor_id;
-// 		createdActors.push(actorId);
-//
-// 		// Ping the actor
-// 		const pingResponse = await fetch(`${RIVET_ENDPOINT}/ping`, {
-// 			method: "GET",
-// 			headers: {
-// 				"x-rivet-target": "actor",
-// 				"x-rivet-actor": actorId,
-// 			},
-// 		});
-// 		if (!pingResponse.ok) throw "Request failed";
-// 	});
-//
-// 	//bench.add(
-// 	//	"wake actor from sleep",
-// 	//	async () => {
-// 	//		if (!wakeActorId) throw "No wake actor ID";
-// 	//
-// 	//		// Ping the actor
-// 	//		const pingResponse = await fetch(`${RIVET_ENDPOINT}/ping`, {
-// 	//			method: "GET",
-// 	//			headers: {
-// 	//				"x-rivet-target": "actor",
-// 	//				"x-rivet-actor": wakeActorId,
-// 	//			},
-// 	//		});
-// 	//
-// 	//		if (!pingResponse.ok) {
-// 	//			console.error(
-// 	//				`Ping failed: ${pingResponse.status} ${pingResponse.statusText}`,
-// 	//			);
-// 	//			const errorText = await pingResponse.text();
-// 	//			console.error(`Error response: ${errorText}`);
-// 	//			throw `Request failed: ${pingResponse.status} ${pingResponse.statusText}`;
-// 	//		}
-// 	//	},
-// 	//	{
-// 	//		beforeEach: async () => {
-// 	//			// Reset promise resolvers for this iteration
-// 	//			started = createPromiseResolver<void>();
-// 	//			stopped = createPromiseResolver<void>();
-// 	//
-// 	//			// Create the actor that will be used for wake benchmarking
-// 	//			console.log('Creating actor');
-// 	//			const wakeActorResponse = await createActor(
-// 	//				namespaceName,
-// 	//				runnerName,
-// 	//				false,
-// 	//				"wake-bench-actor",
-// 	//			);
-// 	//			wakeActorId = wakeActorResponse.actor.actor_id;
-// 	//			createdActors.push(wakeActorId!);
-// 	//
-// 	//			// Wait for actor to start
-// 	//			await started.promise;
-// 	//
-// 	//			// Put actor to sleep initially
-// 	//			runner!.sleepActor(wakeActorId!);
-// 	//			await stopped.promise;
-// 	//		},
-// 	//	},
-// 	//	// TODO(RVT-4979): Add back after sleep cycles fixed
-// 	//	//{
-// 	//	//	beforeAll: async () => {
-// 	//	//		// Create the actor that will be used for wake benchmarking
-// 	//	//		console.log("Creating wake actor...");
-// 	//	//		const wakeActorResponse = await createActor(
-// 	//	//			namespaceName,
-// 	//	//			runnerName,
-// 	//	//			false,
-// 	//	//			"wake-bench-actor",
-// 	//	//		);
-// 	//	//		wakeActorId = wakeActorResponse.actor.actor_id;
-// 	//	//		createdActors.push(wakeActorId!);
-// 	//	//
-// 	//	//		// Wait for actor to start
-// 	//	//		await started.promise;
-// 	//	//	},
-// 	//	//	beforeEach: async () => {
-// 	//	//		console.log("Putting actor to sleep...");
-// 	//	//
-// 	//	//		// Put actor to sleep initially
-// 	//	//		stopped = createPromiseResolver<void>();
-// 	//	//		runner!.sleepActor(wakeActorId!);
-// 	//	//		await stopped.promise;
-// 	//	//	},
-// 	//	//},
-// 	//);
-//
-// 	// Run the benchmark
-// 	console.log("Running benchmarks...");
-// 	await bench.run();
-//
-// 	// Display results
-// 	console.table(bench.table());
-//
-// 	console.log("Benchmark complete!");
-// }
-//
-// // Run the benchmark if this file is executed directly
-// if (import.meta.url === `file://${process.argv[1]}`) {
-// 	runActorLifecycleBenchmark();
-// }

package/benches/utils.ts

@@ -1,143 +0,0 @@
-// import { Runner } from "@/mod";
-// import type { RunnerConfig, ActorConfig } from "@/mod";
-//
-// export const RIVET_ENDPOINT =
-// 	process.env.RIVET_ENDPOINT ?? "http://localhost:6420";
-//
-// export async function createActor(
-// 	namespaceName: string,
-// 	runnerNameSelector: string,
-// 	durable: boolean,
-// 	actorName: string = "bench-actor",
-// ): Promise<any> {
-// 	const response = await fetch(
-// 		`${RIVET_ENDPOINT}/actors?namespace=${namespaceName}`,
-// 		{
-// 			method: "POST",
-// 			headers: {
-// 				"Content-Type": "application/json",
-// 			},
-// 			body: JSON.stringify({
-// 				name: actorName,
-// 				input: btoa("bench-input"),
-// 				runner_name_selector: runnerNameSelector,
-// 				durable,
-// 			}),
-// 		},
-// 	);
-//
-// 	if (!response.ok) {
-// 		throw new Error(
-// 			`Failed to create actor: ${response.status} ${response.statusText}\n${await response.text()}`,
-// 		);
-// 	}
-//
-// 	return response.json();
-// }
-//
-// export async function destroyActor(
-// 	namespaceName: string,
-// 	actorId: string,
-// ): Promise<void> {
-// 	const response = await fetch(
-// 		`${RIVET_ENDPOINT}/actors/${actorId}?namespace=${namespaceName}`,
-// 		{
-// 			method: "DELETE",
-// 		},
-// 	);
-//
-// 	if (!response.ok) {
-// 		throw new Error(
-// 			`Failed to delete actor: ${response.status} ${response.statusText}\n${await response.text()}`,
-// 		);
-// 	}
-// }
-//
-// export async function createNamespace(
-// 	name: string,
-// 	displayName: string,
-// ): Promise<any> {
-// 	const response = await fetch(`${RIVET_ENDPOINT}/namespaces`, {
-// 		method: "POST",
-// 		headers: {
-// 			"Content-Type": "application/json",
-// 		},
-// 		body: JSON.stringify({
-// 			name,
-// 			display_name: displayName,
-// 		}),
-// 	});
-//
-// 	if (!response.ok) {
-// 		console.warn(
-// 			`Failed to create namespace: ${response.status} ${response.statusText}\n${await response.text()}`,
-// 		);
-// 	}
-// }
-//
-// export interface BenchmarkRunnerSetup {
-// 	runner: Runner;
-// 	namespaceName: string;
-// 	runnerName: string;
-// }
-//
-// export async function setupBenchmarkRunner(
-// 	namespaceSuffix: string,
-// 	port: number,
-// 	onActorStart?: (
-// 		actorId: string,
-// 		generation: number,
-// 		config: ActorConfig,
-// 	) => Promise<void>,
-// 	onActorStop?: (actorId: string, generation: number) => Promise<void>,
-// ): Promise<BenchmarkRunnerSetup> {
-// 	const namespaceName = `bench-${crypto.randomUUID().slice(0, 8)}`;
-// 	const runnerName = `bench-runner`;
-//
-// 	let runnerStartedResolver: () => void;
-// 	const runnerStarted = new Promise<void>((resolve) => {
-// 		runnerStartedResolver = resolve;
-// 	});
-//
-// 	const config: RunnerConfig = {
-// 		version: 1,
-// 		endpoint: RIVET_ENDPOINT,
-// 		namespace: namespaceName,
-// 		addresses: { main: { host: "127.0.0.1", port } },
-// 		totalSlots: 100,
-// 		prepopulateActorNames: [],
-// 		runnerName: runnerName,
-// 		runnerKey: "default",
-// 		onConnected: () => {
-// 			runnerStartedResolver();
-// 		},
-// 		onDisconnected: () => {},
-// 		fetch: async (_actorId: string, request: Request) => {
-// 			return new Response("ok", { status: 200 });
-// 		},
-// 		onActorStart: onActorStart || (async () => {}),
-// 		onActorStop: onActorStop || (async () => {}),
-// 	};
-//
-// 	await createNamespace(namespaceName, `Bench ${namespaceSuffix} Namespace`);
-// 	const runner = new Runner(config);
-// 	runner.start();
-// 	await runnerStarted;
-//
-// 	return { runner, namespaceName, runnerName };
-// }
-//
-// export function createPromiseResolver<T = void>(): {
-// 	promise: Promise<T>;
-// 	resolve: (value: T) => void;
-// 	reject: (error: any) => void;
-// } {
-// 	let resolve: (value: T) => void;
-// 	let reject: (error: any) => void;
-// 	const promise = new Promise<T>((res, rej) => {
-// 		resolve = res;
-// 		reject = rej;
-// 	});
-// 	return { promise, resolve: resolve!, reject: reject! };
-// }
-//