rivetkit 2.0.21 → 2.0.22-rc.2

package/src/manager/gateway.ts

@@ -134,8 +134,8 @@ async function handleHttpGatewayPathBased(
  * Routes requests using either path-based routing or header-based routing:
  *
  * Path-based routing (checked first):
- * - /gateway/actors/{actor_id}/tokens/{token}/route/{...path}
- * - /gateway/actors/{actor_id}/route/{...path}
+ * - /gateway/{actor_id}/{...path}
+ * - /gateway/{actor_id}@{token}/{...path}
  *
  * Header-based routing (fallback):
  * - WebSocket requests: Uses sec-websocket-protocol for routing (target.actor, actor.{id})
@@ -340,8 +340,8 @@ async function handleHttpGateway(
 /**
  * Parse actor routing information from path
  * Matches patterns:
- * - /gateway/actors/{actor_id}/tokens/{token}/route/{...path}
- * - /gateway/actors/{actor_id}/route/{...path}
+ * - /gateway/{actor_id}/{...path}
+ * - /gateway/{actor_id}@{token}/{...path}
  */
 export function parseActorPath(path: string): ActorPathInfo | null {
 	// Find query string position (everything from ? onwards, but before fragment)
@@ -374,50 +374,63 @@ export function parseActorPath(path: string): ActorPathInfo | null {
 	// Split the path into segments
 	const segments = basePath.split("/").filter((s) => s.length > 0);
 
-	// Check minimum required segments: gateway, actors, {actor_id}, route
-	if (segments.length < 4) {
+	// Check minimum required segments: gateway, {actor_id}
+	if (segments.length < 2) {
 		return null;
 	}
 
-	// Verify the fixed segments
-	if (segments[0] !== "gateway" || segments[1] !== "actors") {
+	// Verify the first segment is "gateway"
+	if (segments[0] !== "gateway") {
 		return null;
 	}
 
-	// Check for empty actor_id
-	if (segments[2].length === 0) {
+	// Extract actor_id segment (may contain @token)
+	const actorSegment = segments[1];
+
+	// Check for empty actor segment
+	if (actorSegment.length === 0) {
 		return null;
 	}
 
-	const actorId = segments[2];
-
-	// Check for token or direct route
+	// Parse actor_id and optional token from the segment
+	let actorId: string;
 	let token: string | undefined;
-	let remainingPathStartIdx: number;
-
-	if (
-		segments.length >= 6 &&
-		segments[3] === "tokens" &&
-		segments[5] === "route"
-	) {
-		// Pattern with token: /gateway/actors/{actor_id}/tokens/{token}/route/{...path}
-		// Check for empty token
-		if (segments[4].length === 0) {
+
+	const atPos = actorSegment.indexOf("@");
+	if (atPos !== -1) {
+		// Pattern: /gateway/{actor_id}@{token}/{...path}
+		const rawActorId = actorSegment.slice(0, atPos);
+		const rawToken = actorSegment.slice(atPos + 1);
+
+		// Check for empty actor_id or token
+		if (rawActorId.length === 0 || rawToken.length === 0) {
+			return null;
+		}
+
+		// URL-decode both actor_id and token
+		try {
+			actorId = decodeURIComponent(rawActorId);
+			token = decodeURIComponent(rawToken);
+		} catch (e) {
+			// Invalid URL encoding
 			return null;
 		}
-		token = segments[4];
-		remainingPathStartIdx = 6;
-	} else if (segments.length >= 4 && segments[3] === "route") {
-		// Pattern without token: /gateway/actors/{actor_id}/route/{...path}
-		token = undefined;
-		remainingPathStartIdx = 4;
 	} else {
-		return null;
+		// Pattern: /gateway/{actor_id}/{...path}
+		// URL-decode actor_id
+		try {
+			actorId = decodeURIComponent(actorSegment);
+		} catch (e) {
+			// Invalid URL encoding
+			return null;
+		}
+		token = undefined;
 	}
 
-	// Calculate the position in the original path where remaining path starts
+	// Calculate remaining path
+	// The remaining path starts after /gateway/{actor_id[@token]}/
 	let prefixLen = 0;
-	for (let i = 0; i < remainingPathStartIdx; i++) {
+	for (let i = 0; i < 2; i++) {
 		prefixLen += 1 + segments[i].length; // +1 for the slash
 	}
 

package/src/manager/hono-websocket-adapter.ts

@@ -23,16 +23,28 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 	#eventListeners: Map<string, Set<(event: any) => void>> = new Map();
 	#closeCode?: number;
 	#closeReason?: string;
-
-	constructor(ws: WSContext) {
+	readonly rivetRequestId?: ArrayBuffer;
+	readonly isHibernatable: boolean;
+
+	constructor(
+		ws: WSContext,
+		rivetRequestId: ArrayBuffer | undefined,
+		isHibernatable: boolean,
+	) {
 		this.#ws = ws;
+		this.rivetRequestId = rivetRequestId;
+		this.isHibernatable = isHibernatable;
 
 		// The WSContext is already open when we receive it
 		this.#readyState = this.OPEN;
 
 		// Immediately fire the open event
 		setTimeout(() => {
-			this.#fireEvent("open", { type: "open", target: this });
+			this.#fireEvent("open", {
+				type: "open",
+				target: this,
+				rivetRequestId: this.rivetRequestId,
+			});
 		}, 0);
 	}
 
@@ -155,6 +167,7 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 				code,
 				reason,
 				wasClean: code === 1000,
+				rivetRequestId: this.rivetRequestId,
 			});
 		} catch (error) {
 			logger().error({ msg: "error closing websocket", error });
@@ -165,6 +178,7 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 				code: 1006,
 				reason: "Abnormal closure",
 				wasClean: false,
+				rivetRequestId: this.rivetRequestId,
 			});
 		}
 	}
@@ -204,6 +218,8 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 	_handleMessage(data: any): void {
 		// Hono may pass either raw data or a MessageEvent-like object
 		let messageData: string | ArrayBuffer | ArrayBufferView;
+		let rivetRequestId: ArrayBuffer | undefined;
+		let rivetMessageIndex: number | undefined;
 
 		if (typeof data === "string") {
 			messageData = data;
@@ -212,6 +228,14 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 		} else if (data && typeof data === "object" && "data" in data) {
 			// Handle MessageEvent-like objects
 			messageData = data.data;
+
+			// Preserve hibernation-related properties from engine runner
+			if ("rivetRequestId" in data) {
+				rivetRequestId = data.rivetRequestId;
+			}
+			if ("rivetMessageIndex" in data) {
+				rivetMessageIndex = data.rivetMessageIndex;
+			}
 		} else {
 			// Fallback - shouldn't happen in normal operation
 			messageData = String(data);
@@ -222,12 +246,15 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 			dataType: typeof messageData,
 			isArrayBuffer: messageData instanceof ArrayBuffer,
 			dataStr: typeof messageData === "string" ? messageData : "<binary>",
+			rivetMessageIndex,
 		});
 
 		this.#fireEvent("message", {
 			type: "message",
 			target: this,
 			data: messageData,
+			rivetRequestId,
+			rivetMessageIndex,
 		});
 	}
 
@@ -249,6 +276,7 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 			code,
 			reason,
 			wasClean: code === 1000,
+			rivetRequestId: this.rivetRequestId,
 		});
 	}
 

package/src/manager/router.ts

@@ -6,7 +6,6 @@ import {
 	type MiddlewareHandler,
 	type Next,
 } from "hono";
-import { cors as corsMiddleware } from "hono/cors";
 import { createMiddleware } from "hono/factory";
 import { streamSSE } from "hono/streaming";
 import invariant from "invariant";
@@ -23,13 +22,13 @@ import {
 	WS_PROTOCOL_PATH,
 	WS_PROTOCOL_TRANSPORT,
 } from "@/common/actor-router-consts";
+import { cors } from "@/common/cors";
 import {
 	handleHealthRequest,
 	handleMetadataRequest,
 	handleRouteError,
 	handleRouteNotFound,
 	loggerMiddleware,
-	type MetadataResponse,
 } from "@/common/router";
 import {
 	assertUnreachable,
@@ -37,7 +36,7 @@ import {
 	noopNext,
 	stringifyError,
 } from "@/common/utils";
-import { type ActorDriver, HEADER_ACTOR_ID } from "@/driver-helpers/mod";
+import { HEADER_ACTOR_ID } from "@/driver-helpers/mod";
 import type {
 	TestInlineDriverCallRequest,
 	TestInlineDriverCallResponse,
@@ -45,11 +44,9 @@ import type {
 import { createManagerInspectorRouter } from "@/inspector/manager";
 import { isInspectorEnabled, secureInspector } from "@/inspector/utils";
 import {
-	type ActorsCreateRequest,
 	ActorsCreateRequestSchema,
 	type ActorsCreateResponse,
 	ActorsCreateResponseSchema,
-	type ActorsGetOrCreateRequest,
 	ActorsGetOrCreateRequestSchema,
 	type ActorsGetOrCreateResponse,
 	ActorsGetOrCreateResponseSchema,
@@ -57,11 +54,9 @@ import {
 	ActorsListResponseSchema,
 	type Actor as ApiActor,
 } from "@/manager-api/actors";
-import { RivetIdSchema } from "@/manager-api/common";
 import type { AnyClient } from "@/mod";
 import type { RegistryConfig } from "@/registry/config";
 import type { DriverConfig, RunnerConfig } from "@/registry/run-config";
-import { VERSION } from "@/utils";
 import type { ActorOutput, ManagerDriver } from "./driver";
 import { actorGateway, createTestWebSocketProxy } from "./gateway";
 import { logger } from "./log";
@@ -97,7 +92,7 @@ export function createManagerRouter(
 		runConfig.basePath,
 	);
 
-	router.use("*", loggerMiddleware(logger()));
+	router.use("*", loggerMiddleware(logger()), cors());
 
 	// HACK: Add Sec-WebSocket-Protocol header to fix KIT-339
 	//
@@ -148,9 +143,6 @@ function addServerlessRoutes(
 	client: AnyClient,
 	router: OpenAPIHono,
 ) {
-	// Apply CORS
-	if (runConfig.cors) router.use("*", corsMiddleware(runConfig.cors));
-
 	// GET /
 	router.get("/", (c) => {
 		return c.text(
@@ -194,6 +186,13 @@ function addServerlessRoutes(
 		newRunConfig.totalSlots = totalSlots;
 		newRunConfig.runnerName = runnerName;
 		newRunConfig.namespace = namespace;
+		if (newRunConfig.runnerKey) {
+			logger().warn({
+				msg: "runner keys are not supported by serverless runners, this will be overwritten with a random runner key",
+				oldRunnerKey: newRunConfig.runnerKey,
+			});
+			newRunConfig.runnerKey = undefined;
+		}
 
 		// Create new actor driver with updated config
 		const actorDriver = driverConfig.actor(
@@ -223,8 +222,7 @@ function addManagerRoutes(
 	managerDriver: ManagerDriver,
 	router: OpenAPIHono,
 ) {
-	// Serve inspector BEFORE the rest of the routes, since this has a special
-	// CORS config that should take precedence for the `/inspector` path
+	// Inspector
 	if (isInspectorEnabled(runConfig, "manager")) {
 		if (!managerDriver.inspector) {
 			throw new Unsupported("inspector");
@@ -232,7 +230,6 @@ function addManagerRoutes(
 		router.route(
 			"/inspect",
 			new Hono<{ Variables: { inspector: any } }>()
-				.use(corsMiddleware(runConfig.inspector.cors))
 				.use(secureInspector(runConfig))
 				.use((c, next) => {
 					c.set("inspector", managerDriver.inspector!);
@@ -242,9 +239,6 @@ function addManagerRoutes(
 		);
 	}
 
-	// Apply CORS
-	if (runConfig.cors) router.use("*", corsMiddleware(runConfig.cors));
-
 	// Actor gateway
 	router.use("*", actorGateway.bind(undefined, runConfig, managerDriver));
 

package/src/registry/run-config.ts

@@ -1,4 +1,3 @@
-import type { cors } from "hono/cors";
 import type { Logger } from "pino";
 import { z } from "zod";
 import type { ActorDriverBuilder } from "@/actor/driver";
@@ -7,9 +6,7 @@ import { EngingConfigSchema as EngineConfigSchema } from "@/drivers/engine/confi
 import { InspectorConfigSchema } from "@/inspector/config";
 import type { ManagerDriverBuilder } from "@/manager/driver";
 import type { GetUpgradeWebSocket } from "@/utils";
-import { getEnvUniversal } from "@/utils";
-
-type CorsOptions = NonNullable<Parameters<typeof cors>[0]>;
+import { getEnvUniversal, VERSION } from "@/utils";
 
 export const DriverConfigSchema = z.object({
 	/** Machine-readable name to identify this driver by. */
@@ -25,9 +22,6 @@ export const RunnerConfigSchema = z
 	.object({
 		driver: DriverConfigSchema.optional(),
 
-		/** CORS configuration for the router. Uses Hono's CORS middleware options. */
-		cors: z.custom<CorsOptions>().optional(),
-
 		/** @experimental */
 		maxIncomingMessageSize: z.number().optional().default(65_536),
 
@@ -51,7 +45,7 @@ export const RunnerConfigSchema = z
 			.string()
 			.optional()
 			.default(
-				() => getEnvUniversal("RIVET_RUN_ENGINE_VERSION") ?? "25.8.2",
+				() => getEnvUniversal("RIVET_RUN_ENGINE_VERSION") ?? VERSION,
 			),
 
 		/** @experimental */

package/src/remote-manager-driver/actor-http-client.ts

@@ -1,9 +1,5 @@
 import type { ClientConfig } from "@/client/config";
-import {
-	HEADER_RIVET_ACTOR,
-	HEADER_RIVET_TARGET,
-	HEADER_RIVET_TOKEN,
-} from "@/common/actor-router-consts";
+import { HEADER_RIVET_TOKEN } from "@/common/actor-router-consts";
 import { combineUrlPath } from "@/utils";
 import { getEndpoint } from "./api-utils";
 
@@ -15,7 +11,10 @@ export async function sendHttpRequestToActor(
 	// Route through guard port
 	const url = new URL(actorRequest.url);
 	const endpoint = getEndpoint(runConfig);
-	const guardUrl = combineUrlPath(endpoint, url.pathname + url.search);
+	const guardUrl = combineUrlPath(
+		endpoint,
+		`/gateway/${actorId}${url.pathname}${url.search}`,
+	);
 
 	// Handle body properly based on method and presence
 	let bodyToSend: ArrayBuffer | null = null;
@@ -76,8 +75,6 @@ function buildGuardHeadersForHttp(
 		headers.set(key, value);
 	}
 	// Add guard-specific headers
-	headers.set(HEADER_RIVET_TARGET, "actor");
-	headers.set(HEADER_RIVET_ACTOR, actorId);
 	if (runConfig.token) {
 		headers.set(HEADER_RIVET_TOKEN, runConfig.token);
 	}

package/src/remote-manager-driver/actor-websocket-client.ts

@@ -2,13 +2,11 @@ import type { ClientConfig } from "@/client/config";
 import {
 	HEADER_CONN_PARAMS,
 	HEADER_ENCODING,
-	WS_PROTOCOL_ACTOR,
 	WS_PROTOCOL_CONN_ID,
 	WS_PROTOCOL_CONN_PARAMS,
 	WS_PROTOCOL_CONN_TOKEN,
 	WS_PROTOCOL_ENCODING,
 	WS_PROTOCOL_STANDARD as WS_PROTOCOL_RIVETKIT,
-	WS_PROTOCOL_TARGET,
 	WS_PROTOCOL_TOKEN,
 } from "@/common/actor-router-consts";
 import { importWebSocket } from "@/common/websocket";
@@ -30,7 +28,7 @@ export async function openWebSocketToActor(
 
 	// WebSocket connections go through guard
 	const endpoint = getEndpoint(runConfig);
-	const guardUrl = combineUrlPath(endpoint, path);
+	const guardUrl = combineUrlPath(endpoint, `/gateway/${actorId}${path}`);
 
 	logger().debug({
 		msg: "opening websocket to actor via guard",
@@ -42,14 +40,7 @@ export async function openWebSocketToActor(
 	// Create WebSocket connection
 	const ws = new WebSocket(
 		guardUrl,
-		buildWebSocketProtocols(
-			runConfig,
-			actorId,
-			encoding,
-			params,
-			connId,
-			connToken,
-		),
+		buildWebSocketProtocols(runConfig, encoding, params, connId, connToken),
 	);
 
 	// Set binary type to arraybuffer for proper encoding support
@@ -62,7 +53,6 @@ export async function openWebSocketToActor(
 
 export function buildWebSocketProtocols(
 	runConfig: ClientConfig,
-	actorId: string,
 	encoding: Encoding,
 	params?: unknown,
 	connId?: string,
@@ -70,8 +60,6 @@ export function buildWebSocketProtocols(
 ): string[] {
 	const protocols: string[] = [];
 	protocols.push(WS_PROTOCOL_RIVETKIT);
-	protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-	protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
 	protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
 	if (runConfig.token) {
 		protocols.push(`${WS_PROTOCOL_TOKEN}${runConfig.token}`);

package/src/remote-manager-driver/mod.ts

@@ -383,7 +383,6 @@ export class RemoteManagerDriver implements ManagerDriver {
 		// Build protocols
 		const protocols = buildWebSocketProtocols(
 			this.#config,
-			actorId,
 			encoding,
 			params,
 			connId,

package/src/schemas/actor-persist/mod.ts

@@ -1 +1 @@
-export * from "../../../dist/schemas/actor-persist/v1";
+export * from "../../../dist/schemas/actor-persist/v2";

package/src/schemas/actor-persist/versioned.ts

@@ -2,24 +2,36 @@ import {
 	createVersionedDataHandler,
 	type MigrationFn,
 } from "@/common/versioned-data";
-import * as v1 from "../../../dist/schemas/actor-persist/v1";
+import type * as v1 from "../../../dist/schemas/actor-persist/v1";
+import * as v2 from "../../../dist/schemas/actor-persist/v2";
 
-export const CURRENT_VERSION = 1;
+export const CURRENT_VERSION = 2;
 
-export type CurrentPersistedActor = v1.PersistedActor;
-export type CurrentPersistedConnection = v1.PersistedConnection;
-export type CurrentPersistedSubscription = v1.PersistedSubscription;
+export type CurrentPersistedActor = v2.PersistedActor;
+export type CurrentPersistedConnection = v2.PersistedConnection;
+export type CurrentPersistedSubscription = v2.PersistedSubscription;
 export type CurrentGenericPersistedScheduleEvent =
-	v1.GenericPersistedScheduleEvent;
-export type CurrentPersistedScheduleEventKind = v1.PersistedScheduleEventKind;
-export type CurrentPersistedScheduleEvent = v1.PersistedScheduleEvent;
+	v2.GenericPersistedScheduleEvent;
+export type CurrentPersistedScheduleEventKind = v2.PersistedScheduleEventKind;
+export type CurrentPersistedScheduleEvent = v2.PersistedScheduleEvent;
+export type CurrentPersistedHibernatableWebSocket =
+	v2.PersistedHibernatableWebSocket;
 
 const migrations = new Map<number, MigrationFn<any, any>>();
 
+// Migration from v1 to v2: Add hibernatableWebSocket field
+migrations.set(
+	1,
+	(v1Data: v1.PersistedActor): v2.PersistedActor => ({
+		...v1Data,
+		hibernatableWebSocket: [],
+	}),
+);
+
 export const PERSISTED_ACTOR_VERSIONED =
 	createVersionedDataHandler<CurrentPersistedActor>({
 		currentVersion: CURRENT_VERSION,
 		migrations,
-		serializeVersion: (data) => v1.encodePersistedActor(data),
-		deserializeVersion: (bytes) => v1.decodePersistedActor(bytes),
+		serializeVersion: (data) => v2.encodePersistedActor(data),
+		deserializeVersion: (bytes) => v2.decodePersistedActor(bytes),
 	});

package/src/utils.ts

@@ -2,6 +2,7 @@ export { stringifyError } from "@/common/utils";
 export { assertUnreachable } from "./common/utils";
 
 import type { Context as HonoContext, Handler as HonoHandler } from "hono";
+import { stringify as uuidstringify } from "uuid";
 
 import pkgJson from "../package.json" with { type: "json" };
 
@@ -248,3 +249,28 @@ export function combineUrlPath(
 	const fullQuery = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
 	return `${baseUrl.protocol}//${baseUrl.host}${fullPath}${fullQuery}`;
 }
+
+export function arrayBuffersEqual(
+	buf1: ArrayBuffer,
+	buf2: ArrayBuffer,
+): boolean {
+	if (buf1.byteLength !== buf2.byteLength) return false;
+
+	const view1 = new Uint8Array(buf1);
+	const view2 = new Uint8Array(buf2);
+
+	for (let i = 0; i < view1.length; i++) {
+		if (view1[i] !== view2[i]) return false;
+	}
+	return true;
+}
+
+export const EXTRA_ERROR_LOG = {
+	issues: "https://github.com/rivet-dev/rivetkit/issues",
+	support: "https://rivet.dev/discord",
+	version: VERSION,
+};
+
+export function idToStr(id: ArrayBuffer): string {
+	return uuidstringify(new Uint8Array(id));
+}