rivetkit 2.0.24-rc.1 → 2.0.25-rc.1

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

@@ -1,14 +1,11 @@
 import type { Context as HonoContext } from "hono";
 import invariant from "invariant";
-import { generateConnRequestId } from "@/actor/conn";
+import { ActorStopping } from "@/actor/errors";
 import { type ActorRouter, createActorRouter } from "@/actor/router";
-import {
-	handleRawWebSocketHandler,
-	handleWebSocketConnect,
-} from "@/actor/router-endpoints";
+import { routeWebSocket } from "@/actor/router-websocket-endpoints";
 import { createClientWithDriver } from "@/client/client";
 import { ClientConfigSchema } from "@/client/config";
-import { InlineWebSocketAdapter2 } from "@/common/inline-websocket-adapter2";
+import { InlineWebSocketAdapter } from "@/common/inline-websocket-adapter";
 import { noopNext } from "@/common/utils";
 import type {
 	ActorDriver,
@@ -17,19 +14,18 @@ import type {
 	GetForIdInput,
 	GetOrCreateWithKeyInput,
 	GetWithKeyInput,
+	ListActorsInput,
 	ManagerDriver,
 } from "@/driver-helpers/mod";
 import { ManagerInspector } from "@/inspector/manager";
 import { type Actor, ActorFeature, type ActorId } from "@/inspector/mod";
 import type { ManagerDisplayInformation } from "@/manager/driver";
-import {
-	type DriverConfig,
-	type Encoding,
-	PATH_CONNECT_WEBSOCKET,
-	PATH_RAW_WEBSOCKET_PREFIX,
-	type RegistryConfig,
-	type RunConfig,
-	type UniversalWebSocket,
+import type {
+	DriverConfig,
+	Encoding,
+	RegistryConfig,
+	RunConfig,
+	UniversalWebSocket,
 } from "@/mod";
 import type * as schema from "@/schemas/file-system-driver/mod";
 import type { FileSystemGlobalState } from "./global-state";
@@ -157,46 +153,28 @@ export class FileSystemManagerDriver implements ManagerDriver {
 		actorId: string,
 		encoding: Encoding,
 		params: unknown,
-		connId?: string,
-		connToken?: string,
 	): Promise<UniversalWebSocket> {
 		// Handle raw WebSocket paths
 		const pathOnly = path.split("?")[0];
 		const normalizedPath = pathOnly.startsWith("/")
 			? pathOnly
 			: `/${pathOnly}`;
-		if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
-			// Handle standard connect
-			const wsHandler = await handleWebSocketConnect(
-				undefined,
-				this.#runConfig,
-				this.#actorDriver,
-				actorId,
-				encoding,
-				params,
-				generateConnRequestId(),
-				undefined,
-				connId,
-				connToken,
-			);
-			return new InlineWebSocketAdapter2(wsHandler);
-		} else if (
-			normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) ||
-			normalizedPath === "/raw/websocket"
-		) {
-			// Handle websocket proxy
-			// Use the full path with query parameters
-			const wsHandler = await handleRawWebSocketHandler(
-				undefined,
-				path,
-				this.#actorDriver,
-				actorId,
-				undefined,
-			);
-			return new InlineWebSocketAdapter2(wsHandler);
-		} else {
-			throw new Error(`Unreachable path: ${path}`);
-		}
+		const wsHandler = await routeWebSocket(
+			// TODO: Create fake request
+			undefined,
+			normalizedPath,
+			{},
+			this.#runConfig,
+			this.#actorDriver,
+			actorId,
+			encoding,
+			params,
+			undefined,
+			undefined,
+			false,
+			false,
+		);
+		return new InlineWebSocketAdapter(wsHandler);
 	}
 
 	async proxyRequest(
@@ -214,9 +192,7 @@ export class FileSystemManagerDriver implements ManagerDriver {
 		path: string,
 		actorId: string,
 		encoding: Encoding,
-		connParams: unknown,
-		connId?: string,
-		connToken?: string,
+		params: unknown,
 	): Promise<Response> {
 		const upgradeWebSocket = this.#runConfig.getUpgradeWebSocket?.();
 		invariant(upgradeWebSocket, "missing getUpgradeWebSocket");
@@ -226,38 +202,22 @@ export class FileSystemManagerDriver implements ManagerDriver {
 		const normalizedPath = pathOnly.startsWith("/")
 			? pathOnly
 			: `/${pathOnly}`;
-		if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
-			// Handle standard connect
-			const wsHandler = await handleWebSocketConnect(
-				c.req.raw,
-				this.#runConfig,
-				this.#actorDriver,
-				actorId,
-				encoding,
-				connParams,
-				generateConnRequestId(),
-				undefined,
-				connId,
-				connToken,
-			);
-			return upgradeWebSocket(() => wsHandler)(c, noopNext());
-		} else if (
-			normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) ||
-			normalizedPath === "/raw/websocket"
-		) {
-			// Handle websocket proxy
-			// Use the full path with query parameters
-			const wsHandler = await handleRawWebSocketHandler(
-				c.req.raw,
-				path,
-				this.#actorDriver,
-				actorId,
-				undefined,
-			);
-			return upgradeWebSocket(() => wsHandler)(c, noopNext());
-		} else {
-			throw new Error(`Unreachable path: ${path}`);
-		}
+		const wsHandler = await routeWebSocket(
+			// TODO: Create new request with new path
+			c.req.raw,
+			normalizedPath,
+			c.req.header(),
+			this.#runConfig,
+			this.#actorDriver,
+			actorId,
+			encoding,
+			params,
+			undefined,
+			undefined,
+			false,
+			false,
+		);
+		return upgradeWebSocket(() => wsHandler)(c, noopNext());
 	}
 
 	async getForId({
@@ -268,6 +228,9 @@ export class FileSystemManagerDriver implements ManagerDriver {
 		if (!actor.state) {
 			return undefined;
 		}
+		if (this.#state.isActorStopping(actorId)) {
+			throw new ActorStopping(actorId);
+		}
 
 		try {
 			// Load actor state
@@ -341,6 +304,31 @@ export class FileSystemManagerDriver implements ManagerDriver {
 		};
 	}
 
+	async listActors({ name }: ListActorsInput): Promise<ActorOutput[]> {
+		const actors: ActorOutput[] = [];
+		const itr = this.#state.getActorsIterator({});
+
+		for await (const actor of itr) {
+			if (actor.name === name) {
+				actors.push({
+					actorId: actor.actorId,
+					name: actor.name,
+					key: actor.key as string[],
+					createTs: Number(actor.createdAt),
+				});
+			}
+		}
+
+		// Sort by create ts desc (most recent first)
+		actors.sort((a, b) => {
+			const aTs = a.createTs ?? 0;
+			const bTs = b.createTs ?? 0;
+			return bTs - aTs;
+		});
+
+		return actors;
+	}
+
 	displayInformation(): ManagerDisplayInformation {
 		return {
 			name: this.#state.persist ? "File System" : "Memory",

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

@@ -1,4 +1,5 @@
 import type { DriverConfig } from "@/registry/run-config";
+import { importNodeDependencies } from "@/utils/node";
 import { FileSystemActorDriver } from "./actor";
 import { FileSystemGlobalState } from "./global-state";
 import { FileSystemManagerDriver } from "./manager";
@@ -12,6 +13,8 @@ export function createFileSystemOrMemoryDriver(
 	persist: boolean = true,
 	customPath?: string,
 ): DriverConfig {
+	importNodeDependencies();
+
 	const state = new FileSystemGlobalState(persist, customPath);
 	const driverConfig: DriverConfig = {
 		name: persist ? "file-system" : "memory",

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

@@ -1,9 +1,11 @@
-import * as crypto from "node:crypto";
-import * as fsSync from "node:fs";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
 import type { ActorKey } from "@/actor/mod";
+import {
+	getNodeCrypto,
+	getNodeFs,
+	getNodeFsSync,
+	getNodeOs,
+	getNodePath,
+} from "@/utils/node";
 
 /**
  * Generate a deterministic actor ID from name and key
@@ -13,6 +15,7 @@ export function generateActorId(name: string, key: ActorKey): string {
 	const jsonString = JSON.stringify([name, key]);
 
 	// Hash to ensure safe file system names
+	const crypto = getNodeCrypto();
 	const hash = crypto
 		.createHash("sha256")
 		.update(jsonString)
@@ -26,6 +29,7 @@ export function generateActorId(name: string, key: ActorKey): string {
  * Create a hash for a path, normalizing it first
  */
 function createHashForPath(dirPath: string): string {
+	const path = getNodePath();
 	// Normalize the path first
 	const normalizedPath = path.normalize(dirPath);
 
@@ -33,6 +37,7 @@ function createHashForPath(dirPath: string): string {
 	const lastComponent = path.basename(normalizedPath);
 
 	// Create SHA-256 hash
+	const crypto = getNodeCrypto();
 	const hash = crypto
 		.createHash("sha256")
 		.update(normalizedPath)
@@ -45,10 +50,10 @@ function createHashForPath(dirPath: string): string {
 /**
  * Get the storage path for the current working directory or a specified path
  */
-export function getStoragePath(customPath?: string): string {
+export function getStoragePath(): string {
 	const dataPath = getDataPath("rivetkit");
-	const pathToHash = customPath || process.cwd();
-	const dirHash = createHashForPath(pathToHash);
+	const dirHash = createHashForPath(process.cwd());
+	const path = getNodePath();
 	return path.join(dataPath, dirHash);
 }
 
@@ -57,6 +62,7 @@ export function getStoragePath(customPath?: string): string {
  */
 export async function pathExists(path: string): Promise<boolean> {
 	try {
+		const fs = getNodeFs();
 		await fs.access(path);
 		return true;
 	} catch {
@@ -71,6 +77,7 @@ export async function ensureDirectoryExists(
 	directoryPath: string,
 ): Promise<void> {
 	if (!(await pathExists(directoryPath))) {
+		const fs = getNodeFs();
 		await fs.mkdir(directoryPath, { recursive: true });
 	}
 }
@@ -80,6 +87,7 @@ export async function ensureDirectoryExists(
  * All other operations use the async version
  */
 export function ensureDirectoryExistsSync(directoryPath: string): void {
+	const fsSync = getNodeFsSync();
 	if (!fsSync.existsSync(directoryPath)) {
 		fsSync.mkdirSync(directoryPath, { recursive: true });
 	}
@@ -90,7 +98,9 @@ export function ensureDirectoryExistsSync(directoryPath: string): void {
  */
 function getDataPath(appName: string): string {
 	const platform = process.platform;
+	const os = getNodeOs();
 	const homeDir = os.homedir();
+	const path = getNodePath();
 
 	switch (platform) {
 		case "win32":

package/src/engine-process/mod.ts

@@ -1,14 +1,16 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { pipeline } from "node:stream/promises";
 import {
 	ensureDirectoryExists,
 	getStoragePath,
 } from "@/drivers/file-system/utils";
-import { EXTRA_ERROR_LOG } from "@/utils";
+import {
+	getNodeChildProcess,
+	getNodeCrypto,
+	getNodeFs,
+	getNodeFsSync,
+	getNodePath,
+	getNodeStream,
+	importNodeDependencies,
+} from "@/utils/node";
 import { logger } from "./log";
 
 export const ENGINE_PORT = 6420;
@@ -24,10 +26,14 @@ interface EnsureEngineProcessOptions {
 export async function ensureEngineProcess(
 	options: EnsureEngineProcessOptions,
 ): Promise<void> {
+	importNodeDependencies();
+
 	logger().debug({
 		msg: "ensuring engine process",
 		version: options.version,
 	});
+
+	const path = getNodePath();
 	const storageRoot = getStoragePath();
 	const binDir = path.join(storageRoot, "bin");
 	const varDir = path.join(storageRoot, "var");
@@ -62,7 +68,6 @@ export async function ensureEngineProcess(
 			);
 		}
 	}
-
 	// Create log file streams with timestamp in the filename
 	const timestamp = new Date()
 		.toISOString()
@@ -71,8 +76,13 @@ export async function ensureEngineProcess(
 	const stdoutLogPath = path.join(logsDir, `engine-${timestamp}-stdout.log`);
 	const stderrLogPath = path.join(logsDir, `engine-${timestamp}-stderr.log`);
 
-	const stdoutStream = createWriteStream(stdoutLogPath, { flags: "a" });
-	const stderrStream = createWriteStream(stderrLogPath, { flags: "a" });
+	const fsSync = getNodeFsSync();
+	const stdoutStream = fsSync.createWriteStream(stdoutLogPath, {
+		flags: "a",
+	});
+	const stderrStream = fsSync.createWriteStream(stderrLogPath, {
+		flags: "a",
+	});
 
 	logger().debug({
 		msg: "creating engine log files",
@@ -80,30 +90,12 @@ export async function ensureEngineProcess(
 		stderr: stderrLogPath,
 	});
 
-	const child = spawn(binaryPath, ["start"], {
+	const childProcess = getNodeChildProcess();
+	const child = childProcess.spawn(binaryPath, ["start"], {
 		cwd: path.dirname(binaryPath),
 		stdio: ["inherit", "pipe", "pipe"],
 		env: {
 			...process.env,
-			// In development, runners can be terminated without a graceful
-			// shutdown (i.e. SIGKILL instead of SIGTERM). This is treated as a
-			// crash by Rivet Engine in production and implements a backoff for
-			// rescheduling actors in case of a crash loop.
-			//
-			// This is problematic in development since this will cause actors
-			// to become unresponsive if frequently killing your dev server.
-			//
-			// We reduce the timeouts for resetting a runner as healthy in
-			// order to account for this.
-			RIVET__PEGBOARD__RETRY_RESET_DURATION: "100",
-			RIVET__PEGBOARD__BASE_RETRY_TIMEOUT: "100",
-			// Set max exponent to 1 to have a maximum of base_retry_timeout
-			RIVET__PEGBOARD__RESCHEDULE_BACKOFF_MAX_EXPONENT: "1",
-			// Reduce thresholds for faster development iteration
-			//
-			// Default ping interval is 3s, this gives a 2s & 4s grace
-			RIVET__PEGBOARD__RUNNER_ELIGIBLE_THRESHOLD: "5000",
-			RIVET__PEGBOARD__RUNNER_LOST_THRESHOLD: "7000",
 		},
 	});
 
@@ -118,7 +110,6 @@ export async function ensureEngineProcess(
 	if (child.stderr) {
 		child.stderr.pipe(stderrStream);
 	}
-
 	logger().debug({
 		msg: "spawned engine process",
 		pid: child.pid,
@@ -130,7 +121,8 @@ export async function ensureEngineProcess(
 			msg: "engine process exited, please report this error",
 			code,
 			signal,
-			...EXTRA_ERROR_LOG,
+			issues: "https://github.com/rivet-dev/rivetkit/issues",
+			support: "https://rivet.dev/discord",
 		});
 		// Clean up log streams
 		stdoutStream.end();
@@ -194,7 +186,8 @@ async function downloadEngineBinaryIfNeeded(
 	}
 
 	// Generate unique temp file name to prevent parallel download conflicts
-	const tempPath = `${binaryPath}.${randomUUID()}.tmp`;
+	const crypto = getNodeCrypto();
+	const tempPath = `${binaryPath}.${crypto.randomUUID()}.tmp`;
 	const startTime = Date.now();
 
 	logger().debug({
@@ -212,12 +205,18 @@ async function downloadEngineBinaryIfNeeded(
 	}, 5000);
 
 	try {
-		await pipeline(response.body, createWriteStream(tempPath));
+		const stream = getNodeStream();
+		const fsSync = getNodeFsSync();
+		await stream.pipeline(
+			response.body,
+			fsSync.createWriteStream(tempPath),
+		);
 
 		// Clear the slow download warning
 		clearTimeout(slowDownloadWarning);
 
 		// Get file size to verify download
+		const fs = getNodeFs();
 		const stats = await fs.stat(tempPath);
 		const downloadDuration = Date.now() - startTime;
 
@@ -247,9 +246,11 @@ async function downloadEngineBinaryIfNeeded(
 			msg: "engine download failed, please report this error",
 			tempPath,
 			error,
-			...EXTRA_ERROR_LOG,
+			issues: "https://github.com/rivet-dev/rivetkit/issues",
+			support: "https://rivet.dev/discord",
 		});
 		try {
+			const fs = getNodeFs();
 			await fs.unlink(tempPath);
 		} catch (unlinkError) {
 			// Ignore errors when cleaning up (file may not exist)
@@ -257,7 +258,7 @@ async function downloadEngineBinaryIfNeeded(
 		throw error;
 	}
 }
-
+//
 function resolveTargetTriplet(): { targetTriplet: string; extension: string } {
 	return resolveTargetTripletFor(process.platform, process.arch);
 }
@@ -297,7 +298,6 @@ export function resolveTargetTripletFor(
 		`unsupported platform for rivet engine binary: ${platform}/${arch}`,
 	);
 }
-
 async function isEngineRunning(): Promise<boolean> {
 	// Check if the engine is running on the port
 	return await checkIfEngineAlreadyRunningOnPort(ENGINE_PORT);
@@ -346,9 +346,9 @@ async function checkIfEngineAlreadyRunningOnPort(
 	// Port responded but not with OK status
 	return false;
 }
-
 async function fileExists(filePath: string): Promise<boolean> {
 	try {
+		const fs = getNodeFs();
 		await fs.access(filePath);
 		return true;
 	} catch {

package/src/inspector/utils.ts

@@ -1,4 +1,4 @@
-import crypto from "node:crypto";
+// import crypto from "node:crypto";
 import { createMiddleware } from "hono/factory";
 import type { ManagerDriver } from "@/driver-helpers/mod";
 import type { RunConfig } from "@/mod";
@@ -20,10 +20,11 @@ export function compareSecrets(providedSecret: string, validSecret: string) {
 		return false;
 	}
 
-	// Perform timing-safe comparison
-	if (!crypto.timingSafeEqual(a, b)) {
-		return false;
-	}
+	// TODO:
+	// // Perform timing-safe comparison
+	// if (!crypto.timingSafeEqual(a, b)) {
+	// 	return false;
+	// }
 	return true;
 }
 
@@ -77,6 +78,7 @@ export function getInspectorUrl(runConfig: RunnerConfigInput | undefined) {
 
 export const isInspectorEnabled = (
 	runConfig: RunConfig,
+	// TODO(kacper): Remove context in favor of using the gateway, so only context is the actor
 	context: "actor" | "manager",
 ) => {
 	if (typeof runConfig.inspector?.enabled === "boolean") {

package/src/manager/driver.ts

@@ -14,6 +14,7 @@ export interface ManagerDriver {
 	getWithKey(input: GetWithKeyInput): Promise<ActorOutput | undefined>;
 	getOrCreateWithKey(input: GetOrCreateWithKeyInput): Promise<ActorOutput>;
 	createActor(input: CreateInput): Promise<ActorOutput>;
+	listActors(input: ListActorsInput): Promise<ActorOutput[]>;
 
 	sendRequest(actorId: string, actorRequest: Request): Promise<Response>;
 	openWebSocket(
@@ -21,8 +22,6 @@ export interface ManagerDriver {
 		actorId: string,
 		encoding: Encoding,
 		params: unknown,
-		connId?: string,
-		connToken?: string,
 	): Promise<UniversalWebSocket>;
 	proxyRequest(
 		c: HonoContext,
@@ -35,8 +34,6 @@ export interface ManagerDriver {
 		actorId: string,
 		encoding: Encoding,
 		params: unknown,
-		connId?: string,
-		connToken?: string,
 	): Promise<Response>;
 
 	displayInformation(): ManagerDisplayInformation;
@@ -48,11 +45,13 @@ export interface ManagerDriver {
 		router: Hono,
 	) => void;
 
+	// TODO(kacper): Remove this in favor of standard manager API
 	/**
 	 * @internal
 	 */
 	readonly inspector?: ManagerInspector;
 
+	// TODO(kacper): Remove this in favor of ActorDriver.getinspectorToken
 	/**
 	 * Get or create the inspector access token.
 	 * @experimental
@@ -94,8 +93,16 @@ export interface CreateInput<E extends Env = any> {
 	region?: string;
 }
 
+export interface ListActorsInput<E extends Env = any> {
+	c?: HonoContext | undefined;
+	name: string;
+	key?: string;
+	includeDestroyed?: boolean;
+}
+
 export interface ActorOutput {
 	actorId: string;
 	name: string;
 	key: ActorKey;
+	createTs?: number;
 }

package/src/manager/gateway.ts

@@ -1,23 +1,18 @@
 import type { Context as HonoContext, Next } from "hono";
 import type { WSContext } from "hono/ws";
 import { MissingActorHeader, WebSocketsNotEnabled } from "@/actor/errors";
-import type { Encoding, Transport } from "@/client/mod";
+import type { UpgradeWebSocketArgs } from "@/actor/router-websocket-endpoints";
 import {
 	HEADER_RIVET_ACTOR,
-	HEADER_RIVET_NAMESPACE,
 	HEADER_RIVET_TARGET,
 	WS_PROTOCOL_ACTOR,
-	WS_PROTOCOL_CONN_ID,
 	WS_PROTOCOL_CONN_PARAMS,
-	WS_PROTOCOL_CONN_TOKEN,
 	WS_PROTOCOL_ENCODING,
 	WS_PROTOCOL_TARGET,
-	WS_PROTOCOL_TOKEN,
 } from "@/common/actor-router-consts";
-import { deconstructError, noopNext } from "@/common/utils";
-import type { UniversalWebSocket, UpgradeWebSocketArgs } from "@/mod";
+import type { UniversalWebSocket } from "@/mod";
 import type { RunnerConfig } from "@/registry/run-config";
-import { promiseWithResolvers, stringifyError } from "@/utils";
+import { promiseWithResolvers } from "@/utils";
 import type { ManagerDriver } from "./driver";
 import { logger } from "./log";
 
@@ -47,8 +42,6 @@ async function handleWebSocketGatewayPathBased(
 	const protocols = c.req.header("sec-websocket-protocol");
 	let encodingRaw: string | undefined;
 	let connParamsRaw: string | undefined;
-	let connIdRaw: string | undefined;
-	let connTokenRaw: string | undefined;
 
 	if (protocols) {
 		const protocolList = protocols.split(",").map((p) => p.trim());
@@ -59,12 +52,6 @@ async function handleWebSocketGatewayPathBased(
 				connParamsRaw = decodeURIComponent(
 					protocol.substring(WS_PROTOCOL_CONN_PARAMS.length),
 				);
-			} else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
-				connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
-			} else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-				connTokenRaw = protocol.substring(
-					WS_PROTOCOL_CONN_TOKEN.length,
-				);
 			}
 		}
 	}
@@ -85,8 +72,6 @@ async function handleWebSocketGatewayPathBased(
 		actorPathInfo.actorId,
 		encoding as any, // Will be validated by driver
 		connParams,
-		connIdRaw,
-		connTokenRaw,
 	);
 }
 
@@ -230,8 +215,6 @@ async function handleWebSocketGateway(
 	let actorId: string | undefined;
 	let encodingRaw: string | undefined;
 	let connParamsRaw: string | undefined;
-	let connIdRaw: string | undefined;
-	let connTokenRaw: string | undefined;
 
 	if (protocols) {
 		const protocolList = protocols.split(",").map((p) => p.trim());
@@ -239,19 +222,13 @@ async function handleWebSocketGateway(
 			if (protocol.startsWith(WS_PROTOCOL_TARGET)) {
 				target = protocol.substring(WS_PROTOCOL_TARGET.length);
 			} else if (protocol.startsWith(WS_PROTOCOL_ACTOR)) {
-				actorId = protocol.substring(WS_PROTOCOL_ACTOR.length);
+				actorId = decodeURIComponent(protocol.substring(WS_PROTOCOL_ACTOR.length));
 			} else if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
 				encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
 			} else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
 				connParamsRaw = decodeURIComponent(
 					protocol.substring(WS_PROTOCOL_CONN_PARAMS.length),
 				);
-			} else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
-				connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
-			} else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-				connTokenRaw = protocol.substring(
-					WS_PROTOCOL_CONN_TOKEN.length,
-				);
 			}
 		}
 	}
@@ -285,8 +262,6 @@ async function handleWebSocketGateway(
 		actorId,
 		encoding as any, // Will be validated by driver
 		connParams,
-		connIdRaw,
-		connTokenRaw,
 	);
 }
 

package/src/manager/protocol/mod.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { TransportSchema } from "@/actor/protocol/old";
 import { ActorQuerySchema } from "./query";
 
 export * from "./query";
@@ -10,7 +9,6 @@ export const ActorsRequestSchema = z.object({
 
 export const ActorsResponseSchema = z.object({
 	actorId: z.string(),
-	supportedTransports: z.array(TransportSchema),
 });
 
 //export const RivetConfigResponseSchema = z.object({