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

package/src/manager/protocol/query.ts

@@ -3,9 +3,7 @@ import { EncodingSchema } from "@/actor/protocol/serde";
 import {
 	HEADER_ACTOR_ID,
 	HEADER_ACTOR_QUERY,
-	HEADER_CONN_ID,
 	HEADER_CONN_PARAMS,
-	HEADER_CONN_TOKEN,
 	HEADER_ENCODING,
 } from "@/common/actor-router-consts";
 
@@ -69,9 +67,7 @@ export const ConnectWebSocketRequestSchema = z.object({
 
 export const ConnMessageRequestSchema = z.object({
 	actorId: z.string().describe(HEADER_ACTOR_ID),
-	connId: z.string().describe(HEADER_CONN_ID),
 	encoding: EncodingSchema.describe(HEADER_ENCODING),
-	connToken: z.string().describe(HEADER_CONN_TOKEN),
 });
 
 export const ResolveRequestSchema = z.object({

package/src/manager/router.ts

@@ -7,20 +7,16 @@ import {
 	type Next,
 } from "hono";
 import { createMiddleware } from "hono/factory";
-import { streamSSE } from "hono/streaming";
 import invariant from "invariant";
 import { z } from "zod";
 import { ActorNotFound, InvalidRequest, Unsupported } from "@/actor/errors";
 import { serializeActorKey } from "@/actor/keys";
-import type { Client, Encoding, Transport } from "@/client/mod";
+import type { Client, Encoding } from "@/client/mod";
 import {
 	WS_PROTOCOL_ACTOR,
-	WS_PROTOCOL_CONN_ID,
 	WS_PROTOCOL_CONN_PARAMS,
-	WS_PROTOCOL_CONN_TOKEN,
 	WS_PROTOCOL_ENCODING,
-	WS_PROTOCOL_PATH,
-	WS_PROTOCOL_TRANSPORT,
+	WS_TEST_PROTOCOL_PATH,
 } from "@/common/actor-router-consts";
 import { cors } from "@/common/cors";
 import {
@@ -50,12 +46,14 @@ import {
 	ActorsGetOrCreateRequestSchema,
 	type ActorsGetOrCreateResponse,
 	ActorsGetOrCreateResponseSchema,
+	type ActorsListNamesResponse,
+	ActorsListNamesResponseSchema,
 	type ActorsListResponse,
 	ActorsListResponseSchema,
 	type Actor as ApiActor,
 } from "@/manager-api/actors";
 import type { AnyClient } from "@/mod";
-import type { RegistryConfig } from "@/registry/config";
+import { buildActorNames, type RegistryConfig } from "@/registry/config";
 import type { DriverConfig, RunnerConfig } from "@/registry/run-config";
 import type { ActorOutput, ManagerDriver } from "./driver";
 import { actorGateway, createTestWebSocketProxy } from "./gateway";
@@ -81,6 +79,17 @@ function buildOpenApiResponses<T>(schema: T) {
 	};
 }
 
+function buildOpenApiRequestBody<T>(schema: T) {
+	return {
+		required: true,
+		content: {
+			"application/json": {
+				schema,
+			},
+		},
+	};
+}
+
 export function createManagerRouter(
 	registryConfig: RegistryConfig,
 	runConfig: RunnerConfig,
@@ -222,6 +231,7 @@ function addManagerRoutes(
 	managerDriver: ManagerDriver,
 	router: OpenAPIHono,
 ) {
+	// TODO(kacper): Remove this in favor of standard manager API
 	// Inspector
 	if (isInspectorEnabled(runConfig, "manager")) {
 		if (!managerDriver.inspector) {
@@ -290,17 +300,7 @@ function addManagerRoutes(
 			if (key && !name) {
 				return c.json(
 					{
-						error: "When providing 'key', 'name' must also be provided.",
-					},
-					400,
-				);
-			}
-
-			// Validate: must provide either actor_ids or (name + key)
-			if (!actorIdsParsed && !key) {
-				return c.json(
-					{
-						error: "Must provide either 'actor_ids' or both 'name' and 'key'.",
+						error: "Name is required when key is provided.",
 					},
 					400,
 				);
@@ -352,16 +352,33 @@ function addManagerRoutes(
 						}
 					}
 				}
-			} else if (key) {
-				// At this point, name is guaranteed to be defined due to validation above
+			} else if (key && name) {
 				const actorOutput = await managerDriver.getWithKey({
 					c,
-					name: name!,
+					name,
 					key: [key], // Convert string to ActorKey array
 				});
 				if (actorOutput) {
 					actors.push(actorOutput);
 				}
+			} else {
+				if (!name) {
+					return c.json(
+						{
+							error: "Name is required when not using actor_ids.",
+						},
+						400,
+					);
+				}
+
+				// List all actors with the given name
+				const actorOutputs = await managerDriver.listActors({
+					c,
+					name,
+					key,
+					includeDestroyed: false,
+				});
+				actors.push(...actorOutputs);
 			}
 
 			return c.json<ActorsListResponse>({
@@ -372,19 +389,34 @@ function addManagerRoutes(
 		});
 	}
 
+	// GET /actors/names
+	{
+		const route = createRoute({
+			method: "get",
+			path: "/actors/names",
+			request: {
+				query: z.object({
+					namespace: z.string(),
+				}),
+			},
+			responses: buildOpenApiResponses(ActorsListNamesResponseSchema),
+		});
+
+		router.openapi(route, async (c) => {
+			const names = buildActorNames(registryConfig);
+			return c.json<ActorsListNamesResponse>({
+				names,
+			});
+		});
+	}
+
 	// PUT /actors
 	{
 		const route = createRoute({
 			method: "put",
 			path: "/actors",
 			request: {
-				body: {
-					content: {
-						"application/json": {
-							schema: ActorsGetOrCreateRequestSchema,
-						},
-					},
-				},
+				body: buildOpenApiRequestBody(ActorsGetOrCreateRequestSchema),
 			},
 			responses: buildOpenApiResponses(ActorsGetOrCreateResponseSchema),
 		});
@@ -430,13 +462,7 @@ function addManagerRoutes(
 			method: "post",
 			path: "/actors",
 			request: {
-				body: {
-					content: {
-						"application/json": {
-							schema: ActorsCreateRequestSchema,
-						},
-					},
-				},
+				body: buildOpenApiRequestBody(ActorsCreateRequestSchema),
 			},
 			responses: buildOpenApiResponses(ActorsCreateResponseSchema),
 		});
@@ -492,19 +518,12 @@ function addManagerRoutes(
 		router.post(".test/inline-driver/call", async (c) => {
 			// TODO: use openapi instead
 			const buffer = await c.req.arrayBuffer();
-			const {
-				encoding,
-				transport,
-				method,
-				args,
-			}: TestInlineDriverCallRequest = cbor.decode(
-				new Uint8Array(buffer),
-			);
+			const { encoding, method, args }: TestInlineDriverCallRequest =
+				cbor.decode(new Uint8Array(buffer));
 
 			logger().debug({
 				msg: "received inline request",
 				encoding,
-				transport,
 				method,
 				args,
 			});
@@ -541,38 +560,25 @@ function addManagerRoutes(
 				// 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);
+						actorId = decodeURIComponent(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)) {
+					} else if (protocol.startsWith(WS_TEST_PROTOCOL_PATH)) {
 						path = decodeURIComponent(
-							protocol.substring(WS_PROTOCOL_PATH.length),
+							protocol.substring(WS_TEST_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,
-						);
 					}
 				}
 
@@ -581,7 +587,6 @@ function addManagerRoutes(
 					actorId,
 					params,
 					encodingKind: encoding,
-					transport,
 					path: path,
 				});
 
@@ -591,8 +596,6 @@ function addManagerRoutes(
 					actorId,
 					encoding,
 					params,
-					connId,
-					connToken,
 				);
 
 				return await createTestWebSocketProxy(clientWsPromise);
@@ -725,7 +728,7 @@ function createApiActor(
 		key: serializeActorKey(actor.key),
 		namespace_id: "default", // Assert default namespace
 		runner_name_selector: runnerName,
-		create_ts: Date.now(),
+		create_ts: actor.createTs ?? Date.now(),
 		connectable_ts: null,
 		destroy_ts: null,
 		sleep_ts: null,

package/src/manager-api/actors.ts

@@ -15,6 +15,11 @@ export const ActorSchema = z.object({
 });
 export type Actor = z.infer<typeof ActorSchema>;
 
+export const ActorNameSchema = z.object({
+	metadata: z.record(z.string(), z.unknown()),
+});
+export type ActorName = z.infer<typeof ActorNameSchema>;
+
 // MARK: GET /actors
 export const ActorsListResponseSchema = z.object({
 	actors: z.array(ActorSchema),
@@ -61,3 +66,11 @@ export type ActorsGetOrCreateResponse = z.infer<
 // MARK: DELETE /actors/{}
 export const ActorsDeleteResponseSchema = z.object({});
 export type ActorsDeleteResponse = z.infer<typeof ActorsDeleteResponseSchema>;
+
+// MARK: GET /actors/names
+export const ActorsListNamesResponseSchema = z.object({
+	names: z.record(z.string(), ActorNameSchema),
+});
+export type ActorsListNamesResponse = z.infer<
+	typeof ActorsListNamesResponseSchema
+>;

package/src/mod.ts

@@ -1,18 +1,16 @@
-export { generateConnId, generateConnToken } from "@/actor/conn";
 export * from "@/actor/mod";
 export {
 	type AnyClient,
 	type Client,
 	createClientWithDriver,
 } from "@/client/client";
-export { InlineWebSocketAdapter2 } from "@/common/inline-websocket-adapter2";
+export { InlineWebSocketAdapter } from "@/common/inline-websocket-adapter";
 export { noopNext } from "@/common/utils";
 export { createEngineDriver } from "@/drivers/engine/mod";
 export {
 	createFileSystemDriver,
 	createMemoryDriver,
 } from "@/drivers/file-system/mod";
-// Re-export important protocol types and utilities needed by drivers
 export type { ActorQuery } from "@/manager/protocol/query";
 export * from "@/registry/mod";
 export { toUint8Array } from "@/utils";

package/src/registry/mod.ts

@@ -72,7 +72,7 @@ export class Registry<A extends RegistryActors> {
 		}
 
 		// Promise for any async operations we need to wait to complete
-		const readyPromises = [];
+		const readyPromises: Promise<unknown>[] = [];
 
 		// Disable health check if using serverless
 		//
@@ -80,7 +80,7 @@ export class Registry<A extends RegistryActors> {
 		// a serverless runner request, so we do not know what to health check
 		if (config.runnerKind === "serverless") {
 			logger().debug("disabling health check since using serverless");
-			config.disableHealthCheck = true;
+			config.disableMetadataLookup = true;
 		}
 
 		// Auto-configure serverless runner if not in prod
@@ -209,6 +209,23 @@ export class Registry<A extends RegistryActors> {
 			console.log();
 		}
 
+		const { router: hono } = createManagerRouter(
+			this.#config,
+			config,
+			managerDriver,
+			driver,
+			client,
+		);
+
+		// Start server
+		if (!config.disableDefaultServer) {
+			const serverPromise = (async () => {
+				const out = await crossPlatformServe(config, hono);
+				upgradeWebSocket = out.upgradeWebSocket;
+			})();
+			readyPromises.push(serverPromise);
+		}
+
 		// HACK: We need to find a better way to let the driver itself decide when to start the actor driver
 		// Create runner
 		//
@@ -230,22 +247,6 @@ export class Registry<A extends RegistryActors> {
 			});
 		}
 
-		const { router: hono } = createManagerRouter(
-			this.#config,
-			config,
-			managerDriver,
-			driver,
-			client,
-		);
-
-		// Start server
-		if (!config.disableDefaultServer) {
-			(async () => {
-				const out = await crossPlatformServe(config, hono, undefined);
-				upgradeWebSocket = out.upgradeWebSocket;
-			})();
-		}
-
 		return {
 			client,
 			fetch: hono.fetch.bind(hono),
@@ -287,10 +288,9 @@ async function configureServerlessRunner(config: RunnerConfig): Promise<void> {
 			namespace: config.namespace,
 			runnerName: config.runnerName,
 			encoding: config.encoding,
-			transport: config.transport,
 			headers: config.headers,
 			getUpgradeWebSocket: config.getUpgradeWebSocket,
-			disableHealthCheck: true, // We don't need health check for this operation
+			disableMetadataLookup: true, // We don't need health check for this operation
 		};
 
 		// Fetch all datacenters

package/src/registry/serve.ts

@@ -1,20 +1,18 @@
-import { Hono } from "hono";
+import type { Hono } from "hono";
 import { logger } from "./log";
 import type { RunnerConfig } from "./run-config";
 
 export async function crossPlatformServe(
 	runConfig: RunnerConfig,
-	rivetKitRouter: Hono<any>,
-	userRouter: Hono | undefined,
+	app: Hono<any>,
 ) {
-	const app = userRouter ?? new Hono();
-
-	// Import @hono/node-server
+	// Import @hono/node-server using string variable to prevent static analysis
+	const nodeServerModule = "@hono/node-server";
 	let serve: any;
 	try {
 		const dep = await import(
 			/* webpackIgnore: true */
-			"@hono/node-server"
+			nodeServerModule
 		);
 		serve = dep.serve;
 	} catch (err) {
@@ -24,16 +22,13 @@ export async function crossPlatformServe(
 		process.exit(1);
 	}
 
-	// Mount registry
-	// app.route("/registry", rivetKitRouter);
-	app.route("/", rivetKitRouter);
-
-	// Import @hono/node-ws
+	// Import @hono/node-ws using string variable to prevent static analysis
+	const nodeWsModule = "@hono/node-ws";
 	let createNodeWebSocket: any;
 	try {
 		const dep = await import(
 			/* webpackIgnore: true */
-			"@hono/node-ws"
+			nodeWsModule
 		);
 		createNodeWebSocket = dep.createNodeWebSocket;
 	} catch (err) {
@@ -45,7 +40,7 @@ export async function crossPlatformServe(
 
 	// Inject WS
 	const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({
-		app,
+		app: app,
 	});
 
 	// Start server

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

@@ -2,9 +2,7 @@ import type { ClientConfig } from "@/client/config";
 import {
 	HEADER_CONN_PARAMS,
 	HEADER_ENCODING,
-	WS_PROTOCOL_CONN_ID,
 	WS_PROTOCOL_CONN_PARAMS,
-	WS_PROTOCOL_CONN_TOKEN,
 	WS_PROTOCOL_ENCODING,
 	WS_PROTOCOL_STANDARD as WS_PROTOCOL_RIVETKIT,
 	WS_PROTOCOL_TOKEN,
@@ -21,8 +19,6 @@ export async function openWebSocketToActor(
 	actorId: string,
 	encoding: Encoding,
 	params: unknown,
-	connId?: string,
-	connToken?: string,
 ): Promise<UniversalWebSocket> {
 	const WebSocket = await importWebSocket();
 
@@ -40,7 +36,7 @@ export async function openWebSocketToActor(
 	// Create WebSocket connection
 	const ws = new WebSocket(
 		guardUrl,
-		buildWebSocketProtocols(runConfig, encoding, params, connId, connToken),
+		buildWebSocketProtocols(runConfig, encoding, params),
 	);
 
 	// Set binary type to arraybuffer for proper encoding support
@@ -55,25 +51,14 @@ export function buildWebSocketProtocols(
 	runConfig: ClientConfig,
 	encoding: Encoding,
 	params?: unknown,
-	connId?: string,
-	connToken?: string,
 ): string[] {
 	const protocols: string[] = [];
 	protocols.push(WS_PROTOCOL_RIVETKIT);
 	protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
-	if (runConfig.token) {
-		protocols.push(`${WS_PROTOCOL_TOKEN}${runConfig.token}`);
-	}
 	if (params) {
 		protocols.push(
 			`${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`,
 		);
 	}
-	if (connId) {
-		protocols.push(`${WS_PROTOCOL_CONN_ID}${connId}`);
-	}
-	if (connToken) {
-		protocols.push(`${WS_PROTOCOL_CONN_TOKEN}${connToken}`);
-	}
 	return protocols;
 }

package/src/remote-manager-driver/api-endpoints.ts

@@ -25,7 +25,7 @@ export async function getActor(
 	);
 }
 
-// MARK: Get actor by id
+// MARK: Get actor by key
 export async function getActorByKey(
 	config: ClientConfig,
 	name: string,
@@ -39,6 +39,18 @@ export async function getActorByKey(
 	);
 }
 
+// MARK: List actors by name
+export async function listActorsByName(
+	config: ClientConfig,
+	name: string,
+): Promise<ActorsListResponse> {
+	return apiCall<never, ActorsListResponse>(
+		config,
+		"GET",
+		`/actors?name=${encodeURIComponent(name)}`,
+	);
+}
+
 // MARK: Get or create actor by id
 export async function getOrCreateActor(
 	config: ClientConfig,

package/src/remote-manager-driver/api-utils.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import type { ClientConfig } from "@/client/config";
 import { sendHttpRequest } from "@/client/utils";
 import { combineUrlPath } from "@/utils";
@@ -51,5 +52,12 @@ export async function apiCall<TInput = unknown, TOutput = unknown>(
 		skipParseResponse: false,
 		requestVersionedDataHandler: undefined,
 		responseVersionedDataHandler: undefined,
+		requestZodSchema: z.any() as z.ZodType<TInput>,
+		responseZodSchema: z.any() as z.ZodType<TOutput>,
+		// Identity conversions (passthrough for generic API calls)
+		requestToJson: (value) => value,
+		requestToBare: (value) => value,
+		responseFromJson: (value) => value,
+		responseFromBare: (value) => value,
 	});
 }

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

@@ -0,0 +1,58 @@
+import pRetry from "p-retry";
+import type { ClientConfig } from "@/client/client";
+import type { MetadataResponse } from "@/common/router";
+import { stringifyError } from "@/common/utils";
+import { getMetadata } from "./api-endpoints";
+import { getEndpoint } from "./api-utils";
+import { logger } from "./log";
+
+// Global cache to store metadata check promises for each endpoint
+const metadataLookupCache = new Map<string, Promise<MetadataResponse>>();
+
+export async function lookupMetadataCached(
+	config: ClientConfig,
+): Promise<MetadataResponse> {
+	const endpoint = getEndpoint(config);
+
+	// Check if metadata lookup is already in progress or completed for this endpoint
+	const existingPromise = metadataLookupCache.get(endpoint);
+	if (existingPromise) {
+		return existingPromise;
+	}
+
+	// Create and store the promise immediately to prevent racing requests
+	const metadataLookupPromise = pRetry(
+		async () => {
+			logger().debug({
+				msg: "fetching metadata",
+				endpoint,
+			});
+
+			const metadataData = await getMetadata(config);
+
+			logger().debug({
+				msg: "received metadata",
+				endpoint,
+				clientEndpoint: metadataData.clientEndpoint,
+			});
+
+			return metadataData;
+		},
+		{
+			forever: true,
+			minTimeout: 500,
+			maxTimeout: 15_000,
+			onFailedAttempt: (error) => {
+				logger().warn({
+					msg: "failed to fetch metadata, retrying",
+					endpoint,
+					attempt: error.attemptNumber,
+					error: stringifyError(error),
+				});
+			},
+		},
+	);
+
+	metadataLookupCache.set(endpoint, metadataLookupPromise);
+	return metadataLookupPromise;
+}