rivetkit 2.0.5 → 2.0.7-rc.1

package/src/manager/router.ts

@@ -1,64 +1,70 @@
 import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
 import * as cbor from "cbor-x";
-import { Hono } from "hono";
+import {
+	Hono,
+	Context as HonoContext,
+	type MiddlewareHandler,
+	Next,
+} from "hono";
 import { cors as corsMiddleware } from "hono/cors";
 import { createMiddleware } from "hono/factory";
-import type { WSContext } from "hono/ws";
+import { streamSSE } from "hono/streaming";
 import invariant from "invariant";
 import { z } from "zod";
+import { ActorNotFound, Unsupported } from "@/actor/errors";
+import { serializeActorKey } from "@/actor/keys";
+import type { Encoding, Transport } from "@/client/mod";
 import {
-	ActorNotFound,
-	FeatureNotImplemented,
-	MissingActorHeader,
-	Unsupported,
-	WebSocketsNotEnabled,
-} from "@/actor/errors";
-import type { Encoding } from "@/client/mod";
+	WS_PROTOCOL_ACTOR,
+	WS_PROTOCOL_CONN_ID,
+	WS_PROTOCOL_CONN_PARAMS,
+	WS_PROTOCOL_CONN_TOKEN,
+	WS_PROTOCOL_ENCODING,
+	WS_PROTOCOL_PATH,
+	WS_PROTOCOL_TRANSPORT,
+} from "@/common/actor-router-consts";
 import {
 	handleRouteError,
 	handleRouteNotFound,
 	loggerMiddleware,
 } from "@/common/router";
-import { deconstructError, noopNext } from "@/common/utils";
-import { HEADER_ACTOR_ID } from "@/driver-helpers/mod";
+import { deconstructError, noopNext, stringifyError } from "@/common/utils";
+import { type ActorDriver, HEADER_ACTOR_ID } from "@/driver-helpers/mod";
 import type {
 	TestInlineDriverCallRequest,
 	TestInlineDriverCallResponse,
 } from "@/driver-test-suite/test-inline-client-driver";
 import { createManagerInspectorRouter } from "@/inspector/manager";
-import { secureInspector } from "@/inspector/utils";
+import { isInspectorEnabled, secureInspector } from "@/inspector/utils";
 import {
 	type ActorsCreateRequest,
 	ActorsCreateRequestSchema,
+	type ActorsCreateResponse,
 	ActorsCreateResponseSchema,
-} from "@/manager-api/routes/actors-create";
-import { ActorsDeleteResponseSchema } from "@/manager-api/routes/actors-delete";
-import { ActorsGetResponseSchema } from "@/manager-api/routes/actors-get";
-import { ActorsGetByIdResponseSchema } from "@/manager-api/routes/actors-get-by-id";
-import {
-	type ActorsGetOrCreateByIdRequest,
-	ActorsGetOrCreateByIdRequestSchema,
-	ActorsGetOrCreateByIdResponseSchema,
-} from "@/manager-api/routes/actors-get-or-create-by-id";
-import { RivetIdSchema } from "@/manager-api/routes/common";
-import type { UniversalWebSocket, UpgradeWebSocketArgs } from "@/mod";
+	type ActorsGetOrCreateRequest,
+	ActorsGetOrCreateRequestSchema,
+	type ActorsGetOrCreateResponse,
+	ActorsGetOrCreateResponseSchema,
+	type ActorsListResponse,
+	ActorsListResponseSchema,
+	type Actor as ApiActor,
+} from "@/manager-api/actors";
+import { RivetIdSchema } from "@/manager-api/common";
 import type { RegistryConfig } from "@/registry/config";
 import type { RunConfig } from "@/registry/run-config";
-import { stringifyError } from "@/utils";
-import type { ManagerDriver } from "./driver";
+import type { ActorOutput, ManagerDriver } from "./driver";
+import { actorGateway, createTestWebSocketProxy } from "./gateway";
 import { logger } from "./log";
 
-function buildOpenApiResponses<T>(schema: T, validateBody: boolean) {
+function buildOpenApiResponses<T>(schema: T) {
 	return {
 		200: {
 			description: "Success",
-			content: validateBody
-				? {
-						"application/json": {
-							schema,
-						},
-					}
-				: {},
+			content: {
+				"application/json": {
+					schema,
+				},
+			},
 		},
 		400: {
 			description: "User error",
@@ -73,8 +79,8 @@ export function createManagerRouter(
 	registryConfig: RegistryConfig,
 	runConfig: RunConfig,
 	managerDriver: ManagerDriver,
-	validateBody: boolean,
-): { router: Hono; openapi: OpenAPIHono } {
+	serverlessActorDriverBuilder: (() => ActorDriver) | undefined,
+): { router: Hono; openapi: OpenAPIHono; cors: MiddlewareHandler } {
 	const router = new OpenAPIHono({ strict: false }).basePath(
 		runConfig.basePath,
 	);
@@ -85,80 +91,55 @@ export function createManagerRouter(
 		? corsMiddleware(runConfig.cors)
 		: createMiddleware((_c, next) => next());
 
-	// Actor proxy middleware - intercept requests with x-rivet-target=actor
-	router.use("*", cors, async (c, next) => {
-		const target = c.req.header("x-rivet-target");
-		const actorId = c.req.header("x-rivet-actor");
-
-		if (target === "actor") {
-			if (!actorId) {
-				throw new MissingActorHeader();
-			}
-
-			logger().debug({
-				msg: "proxying request to actor",
-				actorId,
-				path: c.req.path,
-				method: c.req.method,
-			});
-
-			// Handle WebSocket upgrade
-			if (c.req.header("upgrade") === "websocket") {
-				const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
-				if (!upgradeWebSocket) {
-					throw new WebSocketsNotEnabled();
-				}
-
-				// For WebSocket, use the driver's proxyWebSocket method
-				// Extract any additional headers that might be needed
-				const encoding =
-					c.req.header("X-RivetKit-Encoding") ||
-					c.req.header("x-rivet-encoding") ||
-					"json";
-				const connParams =
-					c.req.header("X-RivetKit-Conn-Params") ||
-					c.req.header("x-rivet-conn-params");
-				const authData =
-					c.req.header("X-RivetKit-Auth-Data") ||
-					c.req.header("x-rivet-auth-data");
-
-				// Include query string if present
-				const pathWithQuery = c.req.url.includes("?")
-					? c.req.path + c.req.url.substring(c.req.url.indexOf("?"))
-					: c.req.path;
-
-				return await managerDriver.proxyWebSocket(
-					c,
-					pathWithQuery,
-					actorId,
-					encoding as any, // Will be validated by driver
-					connParams ? JSON.parse(connParams) : undefined,
-					authData ? JSON.parse(authData) : undefined,
-				);
-			}
+	if (serverlessActorDriverBuilder) {
+		addServerlessRoutes(serverlessActorDriverBuilder, router, cors);
+	} else {
+		addManagerRoutes(registryConfig, runConfig, managerDriver, router, cors);
+	}
 
-			// Handle regular HTTP requests
-			// Preserve all headers except the routing headers
-			const proxyHeaders = new Headers(c.req.raw.headers);
-			proxyHeaders.delete("x-rivet-target");
-			proxyHeaders.delete("x-rivet-actor");
+	// Error handling
+	router.notFound(handleRouteNotFound);
+	router.onError(handleRouteError);
 
-			// Build the proxy request with the actor URL format
-			const url = new URL(c.req.url);
-			const proxyUrl = new URL(`http://actor${url.pathname}${url.search}`);
+	return { router: router as Hono, openapi: router, cors };
+}
 
-			const proxyRequest = new Request(proxyUrl, {
-				method: c.req.raw.method,
-				headers: proxyHeaders,
-				body: c.req.raw.body,
-				signal: c.req.raw.signal,
-			});
+function addServerlessRoutes(
+	serverlessActorDriverBuilder: () => ActorDriver,
+	router: OpenAPIHono,
+	cors: MiddlewareHandler,
+) {
+	// GET /
+	router.get("/", cors, (c) => {
+		return c.text(
+			"This is a RivetKit server.\n\nLearn more at https://rivetkit.org",
+		);
+	});
 
-			return await managerDriver.proxyRequest(c, proxyRequest, actorId);
-		}
+	// Serverless start endpoint
+	router.get("/start", cors, async (c) => {
+		const actorDriver = serverlessActorDriverBuilder();
+		invariant(
+			actorDriver.serverlessHandleStart,
+			"missing serverlessHandleStart on ActorDriver",
+		);
+		return await actorDriver.serverlessHandleStart(c);
+	});
 
-		return next();
+	router.get("/health", cors, (c) => {
+		return c.text("ok");
 	});
+}
+
+function addManagerRoutes(
+	registryConfig: RegistryConfig,
+	runConfig: RunConfig,
+	managerDriver: ManagerDriver,
+	router: OpenAPIHono,
+	cors: MiddlewareHandler,
+) {
+	// Actor gateway
+	router.use("*", cors, actorGateway.bind(undefined, runConfig, managerDriver));
 
 	// GET /
 	router.get("/", cors, (c) => {
@@ -167,72 +148,99 @@ export function createManagerRouter(
 		);
 	});
 
-	// GET /actors/by-id
+	// GET /actors
 	{
 		const route = createRoute({
 			middleware: [cors],
 			method: "get",
-			path: "/actors/by-id",
+			path: "/actors",
 			request: {
 				query: z.object({
 					name: z.string(),
-					key: z.string(),
+					actor_ids: z.string().optional(),
+					key: z.string().optional(),
 				}),
 			},
-			responses: buildOpenApiResponses(
-				ActorsGetByIdResponseSchema,
-				validateBody,
-			),
+			responses: buildOpenApiResponses(ActorsListResponseSchema),
 		});
 
 		router.openapi(route, async (c) => {
-			const { name, key } = c.req.valid("query");
+			const { name, actor_ids, key } = c.req.valid("query");
+
+			const actorIdsParsed = actor_ids
+				? actor_ids
+						.split(",")
+						.map((id) => id.trim())
+						.filter((id) => id.length > 0)
+				: undefined;
+
+			const actors: ActorOutput[] = [];
+
+			if (actorIdsParsed) {
+				if (actorIdsParsed.length > 32) {
+					return c.json(
+						{
+							error: `Too many actor IDs. Maximum is 32, got ${actorIdsParsed.length}.`,
+						},
+						400,
+					);
+				}
 
-			// Get actor by key from the driver
-			const actorOutput = await managerDriver.getWithKey({
-				c,
-				name,
-				key: [key], // Convert string to ActorKey array
-			});
+				if (actorIdsParsed.length === 0) {
+					return c.json<ActorsListResponse>({
+						actors: [],
+					});
+				}
+
+				for (const actorId of actorIdsParsed) {
+					if (name) {
+						const actorOutput = await managerDriver.getForId({
+							c,
+							name,
+							actorId,
+						});
+						if (actorOutput) {
+							actors.push(actorOutput);
+						}
+					}
+				}
+			} else if (key) {
+				const actorOutput = await managerDriver.getWithKey({
+					c,
+					name,
+					key: [key], // Convert string to ActorKey array
+				});
+				if (actorOutput) {
+					actors.push(actorOutput);
+				}
+			}
 
-			return c.json({
-				actor_id: actorOutput?.actorId || null,
+			return c.json<ActorsListResponse>({
+				actors: actors.map(createApiActor),
 			});
 		});
 	}
 
-	// PUT /actors/by-id
+	// PUT /actors
 	{
 		const route = createRoute({
-			cors: [cors],
+			middleware: [cors],
 			method: "put",
-			path: "/actors/by-id",
+			path: "/actors",
 			request: {
 				body: {
-					content: validateBody
-						? {
-								"application/json": {
-									schema: ActorsGetOrCreateByIdRequestSchema,
-								},
-							}
-						: {},
+					content: {
+						"application/json": {
+							schema: ActorsGetOrCreateRequestSchema,
+						},
+					},
 				},
 			},
-			responses: buildOpenApiResponses(
-				ActorsGetOrCreateByIdResponseSchema,
-				validateBody,
-			),
+			responses: buildOpenApiResponses(ActorsGetOrCreateResponseSchema),
 		});
 
 		router.openapi(route, async (c) => {
-			const body = validateBody
-				? await c.req.json<ActorsGetOrCreateByIdRequest>()
-				: await c.req.json();
-
-			// Parse and validate the request body if validation is enabled
-			if (validateBody) {
-				ActorsGetOrCreateByIdRequestSchema.parse(body);
-			}
+			const body = c.req.valid("json");
 
 			// Check if actor already exists
 			const existingActor = await managerDriver.getWithKey({
@@ -242,8 +250,8 @@ export function createManagerRouter(
 			});
 
 			if (existingActor) {
-				return c.json({
-					actor_id: existingActor.actorId,
+				return c.json<ActorsGetOrCreateResponse>({
+					actor: createApiActor(existingActor),
 					created: false,
 				});
 			}
@@ -259,60 +267,13 @@ export function createManagerRouter(
 				region: undefined, // Not provided in the request schema
 			});
 
-			return c.json({
-				actor_id: newActor.actorId,
+			return c.json<ActorsGetOrCreateResponse>({
+				actor: createApiActor(newActor),
 				created: true,
 			});
 		});
 	}
 
-	// GET /actors/{actor_id}
-	{
-		const route = createRoute({
-			middleware: [cors],
-			method: "get",
-			path: "/actors/{actor_id}",
-			request: {
-				params: z.object({
-					actor_id: RivetIdSchema,
-				}),
-			},
-			responses: buildOpenApiResponses(ActorsGetResponseSchema, validateBody),
-		});
-
-		router.openapi(route, async (c) => {
-			const { actor_id } = c.req.valid("param");
-
-			// Get actor by ID from the driver
-			const actorOutput = await managerDriver.getForId({
-				c,
-				name: "", // TODO: The API doesn't provide the name, this may need to be resolved
-				actorId: actor_id,
-			});
-
-			if (!actorOutput) {
-				throw new ActorNotFound(actor_id);
-			}
-
-			// Transform ActorOutput to match ActorSchema
-			// Note: Some fields are not available from the driver and need defaults
-			const actor = {
-				actor_id: actorOutput.actorId,
-				name: actorOutput.name,
-				key: actorOutput.key,
-				namespace_id: "default", // Assert default namespace
-				runner_name_selector: "rivetkit", // Assert rivetkit runner
-				create_ts: Date.now(), // Not available from driver
-				connectable_ts: null,
-				destroy_ts: null,
-				sleep_ts: null,
-				start_ts: null,
-			};
-
-			return c.json({ actor });
-		});
-	}
-
 	// POST /actors
 	{
 		const route = createRoute({
@@ -321,30 +282,18 @@ export function createManagerRouter(
 			path: "/actors",
 			request: {
 				body: {
-					content: validateBody
-						? {
-								"application/json": {
-									schema: ActorsCreateRequestSchema,
-								},
-							}
-						: {},
+					content: {
+						"application/json": {
+							schema: ActorsCreateRequestSchema,
+						},
+					},
 				},
 			},
-			responses: buildOpenApiResponses(
-				ActorsCreateResponseSchema,
-				validateBody,
-			),
+			responses: buildOpenApiResponses(ActorsCreateResponseSchema),
 		});
 
 		router.openapi(route, async (c) => {
-			const body = validateBody
-				? await c.req.json<ActorsCreateRequest>()
-				: await c.req.json();
-
-			// Parse and validate the request body if validation is enabled
-			if (validateBody) {
-				ActorsCreateRequestSchema.parse(body);
-			}
+			const body = c.req.valid("json");
 
 			// Create actor using the driver
 			const actorOutput = await managerDriver.createActor({
@@ -358,20 +307,9 @@ export function createManagerRouter(
 			});
 
 			// Transform ActorOutput to match ActorSchema
-			const actor = {
-				actor_id: actorOutput.actorId,
-				name: actorOutput.name,
-				key: actorOutput.key,
-				namespace_id: "default", // Assert default namespace
-				runner_name_selector: "rivetkit", // Assert rivetkit runner
-				create_ts: Date.now(),
-				connectable_ts: null,
-				destroy_ts: null,
-				sleep_ts: null,
-				start_ts: null,
-			};
-
-			return c.json({ actor });
+			const actor = createApiActor(actorOutput);
+
+			return c.json<ActorsCreateResponse>({ actor });
 		});
 	}
 
@@ -427,7 +365,8 @@ export function createManagerRouter(
 				response = { err };
 			}
 
-			return c.body(cbor.encode(response));
+			// TODO: Remove any
+			return c.body(cbor.encode(response) as any);
 		});
 
 		router.get(".test/inline-driver/connect-websocket/*", async (c) => {
@@ -435,25 +374,52 @@ export function createManagerRouter(
 			invariant(upgradeWebSocket, "websockets not supported on this platform");
 
 			return upgradeWebSocket(async (c: any) => {
-				const {
-					path,
-					actorId,
-					params: paramsRaw,
-					encodingKind,
-				} = c.req.query() as {
-					path: string;
-					actorId: string;
-					params?: string;
-					encodingKind: Encoding;
-				};
-				const params =
-					paramsRaw !== undefined ? JSON.parse(paramsRaw) : undefined;
+				// Extract information from sec-websocket-protocol header
+				const protocolHeader = c.req.header("sec-websocket-protocol") || "";
+				const protocols = protocolHeader.split(/,\s*/);
+
+				// Parse protocols to extract connection info
+				let actorId = "";
+				let encoding: Encoding = "bare";
+				let transport: Transport = "websocket";
+				let path = "";
+				let params: unknown;
+				let connId: string | undefined;
+				let connToken: string | undefined;
+
+				for (const protocol of protocols) {
+					if (protocol.startsWith(WS_PROTOCOL_ACTOR)) {
+						actorId = protocol.substring(WS_PROTOCOL_ACTOR.length);
+					} else if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+						encoding = protocol.substring(
+							WS_PROTOCOL_ENCODING.length,
+						) as Encoding;
+					} else if (protocol.startsWith(WS_PROTOCOL_TRANSPORT)) {
+						transport = protocol.substring(
+							WS_PROTOCOL_TRANSPORT.length,
+						) as Transport;
+					} else if (protocol.startsWith(WS_PROTOCOL_PATH)) {
+						path = decodeURIComponent(
+							protocol.substring(WS_PROTOCOL_PATH.length),
+						);
+					} else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+						const paramsRaw = decodeURIComponent(
+							protocol.substring(WS_PROTOCOL_CONN_PARAMS.length),
+						);
+						params = JSON.parse(paramsRaw);
+					} else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
+						connId = protocol.substring(WS_PROTOCOL_CONN_ID.length);
+					} else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
+						connToken = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+					}
+				}
 
 				logger().debug({
 					msg: "received test inline driver websocket",
 					actorId,
 					params,
-					encodingKind,
+					encodingKind: encoding,
+					transport,
 					path: path,
 				});
 
@@ -461,11 +427,13 @@ export function createManagerRouter(
 				const clientWsPromise = managerDriver.openWebSocket(
 					path,
 					actorId,
-					encodingKind,
+					encoding,
 					params,
+					connId,
+					connToken,
 				);
 
-				return await createTestWebSocketProxy(clientWsPromise, "standard");
+				return await createTestWebSocketProxy(clientWsPromise);
 			})(c, noopNext());
 		});
 
@@ -500,6 +468,7 @@ export function createManagerRouter(
 						method: c.req.method,
 						headers: c.req.raw.headers,
 						body: c.req.raw.body,
+						duplex: "half",
 					}),
 				);
 
@@ -525,14 +494,60 @@ export function createManagerRouter(
 				);
 			}
 		});
+
+		// Test endpoint to force disconnect a connection non-cleanly
+		router.post("/.test/force-disconnect", async (c) => {
+			const actorId = c.req.query("actor");
+			const connId = c.req.query("conn");
+
+			if (!actorId || !connId) {
+				return c.text("Missing actor or conn query parameters", 400);
+			}
+
+			logger().debug({
+				msg: "forcing unclean disconnect",
+				actorId,
+				connId,
+			});
+
+			try {
+				// Send a special request to the actor to force disconnect the connection
+				const response = await managerDriver.sendRequest(
+					actorId,
+					new Request(`http://actor/.test/force-disconnect?conn=${connId}`, {
+						method: "POST",
+					}),
+				);
+
+				if (!response.ok) {
+					const text = await response.text();
+					return c.text(
+						`Failed to force disconnect: ${text}`,
+						response.status as any,
+					);
+				}
+
+				return c.json({ success: true });
+			} catch (error) {
+				logger().error({
+					msg: "error forcing disconnect",
+					error: stringifyError(error),
+				});
+				return c.text(`Error: ${error}`, 500);
+			}
+		});
 	}
 
+	router.get("/health", cors, (c) => {
+		return c.text("ok");
+	});
+
 	managerDriver.modifyManagerRouter?.(
 		registryConfig,
 		router as unknown as Hono,
 	);
 
-	if (runConfig.inspector?.enabled) {
+	if (isInspectorEnabled(runConfig, "manager")) {
 		if (!managerDriver.inspector) {
 			throw new Unsupported("inspector");
 		}
@@ -548,233 +563,19 @@ export function createManagerRouter(
 				.route("/", createManagerInspectorRouter()),
 		);
 	}
-
-	// Error handling
-	router.notFound(handleRouteNotFound);
-	router.onError(handleRouteError);
-
-	return { router: router as Hono, openapi: router };
 }
-/**
- * Creates a WebSocket proxy for test endpoints that forwards messages between server and client WebSockets
- */
-async function createTestWebSocketProxy(
-	clientWsPromise: Promise<UniversalWebSocket>,
-	connectionType: string,
-): Promise<UpgradeWebSocketArgs> {
-	// Store a reference to the resolved WebSocket
-	let clientWs: UniversalWebSocket | null = null;
-	try {
-		// Resolve the client WebSocket promise
-		logger().debug({ msg: "awaiting client websocket promise" });
-		const ws = await clientWsPromise;
-		clientWs = ws;
-		logger().debug({
-			msg: "client websocket promise resolved",
-			constructor: ws?.constructor.name,
-		});
 
-		// Wait for ws to open
-		await new Promise<void>((resolve, reject) => {
-			const onOpen = () => {
-				logger().debug({ msg: "test websocket connection opened" });
-				resolve();
-			};
-			const onError = (error: any) => {
-				logger().error({ msg: "test websocket connection failed", error });
-				reject(
-					new Error(`Failed to open WebSocket: ${error.message || error}`),
-				);
-			};
-			ws.addEventListener("open", onOpen);
-			ws.addEventListener("error", onError);
-		});
-	} catch (error) {
-		logger().error({
-			msg: `failed to establish client ${connectionType} websocket connection`,
-			error,
-		});
-		return {
-			onOpen: (_evt, serverWs) => {
-				serverWs.close(1011, "Failed to establish connection");
-			},
-			onMessage: () => {},
-			onError: () => {},
-			onClose: () => {},
-		};
-	}
-
-	// Create WebSocket proxy handlers to relay messages between client and server
+function createApiActor(actor: ActorOutput): ApiActor {
 	return {
-		onOpen: (_evt: any, serverWs: WSContext) => {
-			logger().debug({
-				msg: `test ${connectionType} websocket connection opened`,
-			});
-
-			// Check WebSocket type
-			logger().debug({
-				msg: "clientWs info",
-				constructor: clientWs.constructor.name,
-				hasAddEventListener: typeof clientWs.addEventListener === "function",
-				readyState: clientWs.readyState,
-			});
-
-			// Add message handler to forward messages from client to server
-			clientWs.addEventListener("message", (clientEvt: MessageEvent) => {
-				logger().debug({
-					msg: `test ${connectionType} websocket connection message from client`,
-					dataType: typeof clientEvt.data,
-					isBlob: clientEvt.data instanceof Blob,
-					isArrayBuffer: clientEvt.data instanceof ArrayBuffer,
-					dataConstructor: clientEvt.data?.constructor?.name,
-					dataStr:
-						typeof clientEvt.data === "string"
-							? clientEvt.data.substring(0, 100)
-							: undefined,
-				});
-
-				if (serverWs.readyState === 1) {
-					// OPEN
-					// Handle Blob data
-					if (clientEvt.data instanceof Blob) {
-						clientEvt.data
-							.arrayBuffer()
-							.then((buffer) => {
-								logger().debug({
-									msg: "converted client blob to arraybuffer, sending to server",
-									bufferSize: buffer.byteLength,
-								});
-								serverWs.send(buffer as any);
-							})
-							.catch((error) => {
-								logger().error({
-									msg: "failed to convert blob to arraybuffer",
-									error,
-								});
-							});
-					} else {
-						logger().debug({
-							msg: "sending client data directly to server",
-							dataType: typeof clientEvt.data,
-							dataLength:
-								typeof clientEvt.data === "string"
-									? clientEvt.data.length
-									: undefined,
-						});
-						serverWs.send(clientEvt.data as any);
-					}
-				}
-			});
-
-			// Add close handler to close server when client closes
-			clientWs.addEventListener("close", (clientEvt: any) => {
-				logger().debug({
-					msg: `test ${connectionType} websocket connection closed`,
-				});
-
-				if (serverWs.readyState !== 3) {
-					// Not CLOSED
-					serverWs.close(clientEvt.code, clientEvt.reason);
-				}
-			});
-
-			// Add error handler
-			clientWs.addEventListener("error", () => {
-				logger().debug({
-					msg: `test ${connectionType} websocket connection error`,
-				});
-
-				if (serverWs.readyState !== 3) {
-					// Not CLOSED
-					serverWs.close(1011, "Error in client websocket");
-				}
-			});
-		},
-		onMessage: (evt: { data: any }) => {
-			logger().debug({
-				msg: "received message from server",
-				dataType: typeof evt.data,
-				isBlob: evt.data instanceof Blob,
-				isArrayBuffer: evt.data instanceof ArrayBuffer,
-				dataConstructor: evt.data?.constructor?.name,
-				dataStr:
-					typeof evt.data === "string" ? evt.data.substring(0, 100) : undefined,
-			});
-
-			// Forward messages from server websocket to client websocket
-			if (clientWs.readyState === 1) {
-				// OPEN
-				// Handle Blob data
-				if (evt.data instanceof Blob) {
-					evt.data
-						.arrayBuffer()
-						.then((buffer) => {
-							logger().debug({
-								msg: "converted blob to arraybuffer, sending",
-								bufferSize: buffer.byteLength,
-							});
-							clientWs.send(buffer);
-						})
-						.catch((error) => {
-							logger().error({
-								msg: "failed to convert blob to arraybuffer",
-								error,
-							});
-						});
-				} else {
-					logger().debug({
-						msg: "sending data directly",
-						dataType: typeof evt.data,
-						dataLength:
-							typeof evt.data === "string" ? evt.data.length : undefined,
-					});
-					clientWs.send(evt.data);
-				}
-			}
-		},
-		onClose: (
-			event: {
-				wasClean: boolean;
-				code: number;
-				reason: string;
-			},
-			serverWs: WSContext,
-		) => {
-			logger().debug({
-				msg: `server ${connectionType} websocket closed`,
-				wasClean: event.wasClean,
-				code: event.code,
-				reason: event.reason,
-			});
-
-			// HACK: Close socket in order to fix bug with Cloudflare leaving WS in closing state
-			// https://github.com/cloudflare/workerd/issues/2569
-			serverWs.close(1000, "hack_force_close");
-
-			// Close the client websocket when the server websocket closes
-			if (
-				clientWs &&
-				clientWs.readyState !== clientWs.CLOSED &&
-				clientWs.readyState !== clientWs.CLOSING
-			) {
-				// Don't pass code/message since this may affect how close events are triggered
-				clientWs.close(1000, event.reason);
-			}
-		},
-		onError: (error: unknown) => {
-			logger().error({
-				msg: `error in server ${connectionType} websocket`,
-				error,
-			});
-
-			// Close the client websocket on error
-			if (
-				clientWs &&
-				clientWs.readyState !== clientWs.CLOSED &&
-				clientWs.readyState !== clientWs.CLOSING
-			) {
-				clientWs.close(1011, "Error in server websocket");
-			}
-		},
+		actor_id: actor.actorId,
+		name: actor.name,
+		key: serializeActorKey(actor.key),
+		namespace_id: "default", // Assert default namespace
+		runner_name_selector: "rivetkit", // Assert rivetkit runner
+		create_ts: Date.now(),
+		connectable_ts: null,
+		destroy_ts: null,
+		sleep_ts: null,
+		start_ts: null,
 	};
 }