rivetkit 2.0.9 → 2.0.10

package/src/registry/run-config.ts

@@ -2,10 +2,12 @@ import type { cors } from "hono/cors";
 import type { Logger } from "pino";
 import { z } from "zod";
 import type { ActorDriverBuilder } from "@/actor/driver";
-import { ClientConfigSchema } from "@/client/config";
 import { LogLevelSchema } from "@/common/log";
+import { EngingConfigSchema as EngineConfigSchema } from "@/drivers/engine/config";
 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]>;
 
@@ -19,49 +21,116 @@ export const DriverConfigSchema = z.object({
 export type DriverConfig = z.infer<typeof DriverConfigSchema>;
 
 /** Base config used for the actor config across all platforms. */
-export const RunConfigSchema = ClientConfigSchema.extend({
-	driver: DriverConfigSchema.optional(),
-
-	/** CORS configuration for the router. Uses Hono's CORS middleware options. */
-	cors: z.custom<CorsOptions>().optional(),
-
-	maxIncomingMessageSize: z.number().optional().default(65_536),
-
-	inspector: InspectorConfigSchema,
-
-	/** @experimental */
-	disableServer: z.boolean().optional().default(false),
-
-	/** @experimental */
-	disableActorDriver: z.boolean().optional().default(false),
-
-	/**
-	 * @experimental
-	 *
-	 * Base path for the router. This is used to prefix all routes.
-	 * For example, if the base path is `/api`, then the route `/actors` will be
-	 * available at `/api/actors`.
-	 */
-	basePath: z.string().optional().default("/"),
-
-	/**
-	 * @experimental
-	 *
-	 * Disable welcome message.
-	 * */
-	noWelcome: z.boolean().optional().default(false),
-
-	/**
-	 * @experimental
-	 * */
-	logging: z
-		.object({
-			baseLogger: z.custom<Logger>().optional(),
-			level: LogLevelSchema.optional(),
-		})
-		.optional()
-		.default({}),
-}).default({});
-
-export type RunConfig = z.infer<typeof RunConfigSchema>;
-export type RunConfigInput = z.input<typeof RunConfigSchema>;
+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),
+
+		/** @experimental */
+		inspector: InspectorConfigSchema,
+
+		/** @experimental */
+		disableDefaultServer: z.boolean().optional().default(false),
+
+		/** @experimental */
+		defaultServerPort: z.number().default(6420),
+
+		/** @experimental */
+		runEngine: z
+			.boolean()
+			.optional()
+			.default(() => getEnvUniversal("RIVET_RUN_ENGINE") === "1"),
+
+		/** @experimental */
+		runEngineVersion: z
+			.string()
+			.optional()
+			.default(() => getEnvUniversal("RIVET_RUN_ENGINE_VERSION") ?? "25.7.3"),
+
+		/** @experimental */
+		overrideServerAddress: z.string().optional(),
+
+		/** @experimental */
+		disableActorDriver: z.boolean().optional().default(false),
+
+		/**
+		 * @experimental
+		 *
+		 * Whether to run runners normally or have them managed
+		 * serverlessly (by the Rivet Engine for example).
+		 */
+		runnerKind: z
+			.enum(["serverless", "normal"])
+			.optional()
+			.default(() =>
+				getEnvUniversal("RIVET_RUNNER_KIND") === "serverless"
+					? "serverless"
+					: "normal",
+			),
+		totalSlots: z.number().optional(),
+
+		/**
+		 * @experimental
+		 *
+		 * Base path for the router. This is used to prefix all routes.
+		 * For example, if the base path is `/api`, then the route `/actors` will be
+		 * available at `/api/actors`.
+		 */
+		basePath: z.string().optional().default("/"),
+
+		/**
+		 * @experimental
+		 *
+		 * Disable welcome message.
+		 * */
+		noWelcome: z.boolean().optional().default(false),
+
+		/**
+		 * @experimental
+		 * */
+		logging: z
+			.object({
+				baseLogger: z.custom<Logger>().optional(),
+				level: LogLevelSchema.optional(),
+			})
+			.optional()
+			.default({}),
+
+		/**
+		 * @experimental
+		 *
+		 * Automatically configure serverless runners in the engine.
+		 * Can only be used when runnerKind is "serverless".
+		 * If true, uses default configuration. Can also provide custom configuration.
+		 */
+		autoConfigureServerless: z
+			.union([
+				z.boolean(),
+				z.object({
+					url: z.string().optional(),
+					headers: z.record(z.string(), z.string()).optional(),
+					maxRunners: z.number().optional(),
+					minRunners: z.number().optional(),
+					requestLifespan: z.number().optional(),
+					runnersMargin: z.number().optional(),
+					slotsPerRunner: z.number().optional(),
+				}),
+			])
+			.optional(),
+
+		// This is a function to allow for lazy configuration of upgradeWebSocket on the
+		// fly. This is required since the dependencies that upgradeWebSocket
+		// (specifically Node.js) can sometimes only be specified after the router is
+		// created or must be imported async using `await import(...)`
+		getUpgradeWebSocket: z.custom<GetUpgradeWebSocket>().optional(),
+	})
+	.merge(EngineConfigSchema.removeDefault())
+	.default({});
+
+export type RunnerConfig = z.infer<typeof RunnerConfigSchema>;
+export type RunnerConfigInput = z.input<typeof RunnerConfigSchema>;

package/src/registry/serve.ts

@@ -1,7 +1,9 @@
 import { 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,
 ) {
@@ -47,7 +49,7 @@ export async function crossPlatformServe(
 	});
 
 	// Start server
-	const port = 6420;
+	const port = runConfig.defaultServerPort;
 	const server = serve({ fetch: app.fetch, port }, () =>
 		logger().info({ msg: "server listening", port }),
 	);

package/src/serde.ts

@@ -3,7 +3,7 @@ import invariant from "invariant";
 import { assertUnreachable } from "@/common/utils";
 import type { VersionedDataHandler } from "@/common/versioned-data";
 import type { Encoding } from "@/mod";
-import { jsonStringifyCompat } from "./actor/protocol/serde";
+import { jsonParseCompat, jsonStringifyCompat } from "./actor/protocol/serde";
 
 export function uint8ArrayToBase64(uint8Array: Uint8Array): string {
 	// Check if Buffer is available (Node.js)
@@ -78,11 +78,11 @@ export function deserializeWithEncoding<T>(
 ): T {
 	if (encoding === "json") {
 		if (typeof buffer === "string") {
-			return JSON.parse(buffer);
+			return jsonParseCompat(buffer);
 		} else {
 			const decoder = new TextDecoder("utf-8");
 			const jsonString = decoder.decode(buffer);
-			return JSON.parse(jsonString);
+			return jsonParseCompat(jsonString);
 		}
 	} else if (encoding === "cbor") {
 		invariant(

package/src/test/config.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { RunConfigSchema } from "@/registry/run-config";
+import { RunnerConfigSchema } from "@/registry/run-config";
 
-export const ConfigSchema = RunConfigSchema.removeDefault()
+export const ConfigSchema = RunnerConfigSchema.removeDefault()
 	.extend({
 		hostname: z
 			.string()

package/src/test/mod.ts

@@ -10,8 +10,9 @@ import {
 	getInspectorUrl,
 } from "@/inspector/utils";
 import { createManagerRouter } from "@/manager/router";
+import { createClientWithDriver } from "@/mod";
 import type { Registry } from "@/registry/mod";
-import { RunConfigSchema } from "@/registry/run-config";
+import { RunnerConfigSchema } from "@/registry/run-config";
 import { ConfigSchema, type InputConfig } from "./config";
 import { logger } from "./log";
 
@@ -27,15 +28,17 @@ function serve(registry: Registry<any>, inputConfig?: InputConfig): ServerType {
 	}
 
 	// Create router
-	const runConfig = RunConfigSchema.parse(inputConfig);
+	const runConfig = RunnerConfigSchema.parse(inputConfig);
 	const driver = inputConfig.driver ?? createFileSystemOrMemoryDriver(false);
 	const managerDriver = driver.manager(registry.config, config);
+	const client = createClientWithDriver(managerDriver);
 	configureInspectorAccessToken(config, managerDriver);
 	const { router } = createManagerRouter(
 		registry.config,
 		runConfig,
 		managerDriver,
-		undefined,
+		driver,
+		client,
 	);
 
 	// Inject WebSocket

package/src/utils.ts

@@ -31,6 +31,8 @@ export type UpgradeWebSocket = (
 	createEvents: (c: HonoContext) => any,
 ) => HonoHandler;
 
+export type GetUpgradeWebSocket = () => UpgradeWebSocket;
+
 export function getEnvUniversal(key: string): string | undefined {
 	if (typeof Deno !== "undefined") {
 		return Deno.env.get(key);