rivetkit 2.3.0-rc.10 → 2.3.0-rc.11

package/src/actor/instance/mod.ts

@@ -9,22 +9,21 @@ import {
 	type SpanStatusInput,
 	type Traces,
 } from "@rivetkit/traces";
-import { ActorMetrics, type StartupTimingKey } from "@/actor/metrics";
 import invariant from "invariant";
+import { ActorMetrics, type StartupTimingKey } from "@/actor/metrics";
 import type { Client } from "@/client/client";
+import type { ActorKey } from "@/client/query";
 import { getBaseLogger, getIncludeTarget, type Logger } from "@/common/log";
 import { stringifyError } from "@/common/utils";
 import type { UniversalWebSocket } from "@/common/websocket-interface";
 import { ActorInspector } from "@/inspector/actor-inspector";
-import type { ActorKey } from "@/client/query";
 import type { Registry } from "@/mod";
 import {
 	ACTOR_VERSIONED,
 	CONN_VERSIONED,
 } from "@/schemas/actor-persist/versioned";
-import { EXTRA_ERROR_LOG } from "@/utils";
+import { EXTRA_ERROR_LOG, promiseWithResolvers } from "@/utils";
 import { getRivetExperimentalOtel } from "@/utils/env-vars";
-import { promiseWithResolvers } from "@/utils";
 import {
 	type Actions,
 	type ActorConfig,
@@ -32,16 +31,13 @@ import {
 	ActorConfigSchema,
 	getRunFunction,
 } from "../config";
-import type { ConnDriver } from "../conn/driver";
-import { createHttpDriver } from "../conn/drivers/http";
 import {
-	HibernatableWebSocketAckState,
 	handleInboundHibernatableWebSocketMessage as applyInboundHibernatableWebSocketMessage,
+	HibernatableWebSocketAckState,
 } from "../conn/hibernatable-websocket-ack-state";
 import {
-	CONN_DRIVER_SYMBOL,
-	CONN_STATE_MANAGER_SYMBOL,
 	type AnyConn,
+	CONN_STATE_MANAGER_SYMBOL,
 	type Conn,
 	type ConnId,
 } from "../conn/mod";
@@ -50,7 +46,7 @@ import {
 	type PersistedConn,
 } from "../conn/persisted";
 import {
-	ActionContext,
+	type ActionContext,
 	ActorContext,
 	RequestContext,
 	WebSocketContext,
@@ -79,20 +75,16 @@ import {
 import { ConnectionManager } from "./connection-manager";
 import { EventManager } from "./event-manager";
 import { KEYS, workflowStoragePrefix } from "./keys";
-import {
-	type PreloadedEntries,
-	type PreloadHit,
-	type PreloadMap,
-} from "./preload-map";
 import {
 	convertActorFromBarePersisted,
 	type PersistedActor,
 } from "./persisted";
+import type { PreloadedEntries, PreloadMap } from "./preload-map";
 import { QueueManager } from "./queue-manager";
 import { ScheduleManager } from "./schedule-manager";
 import { type SaveStateOptions, StateManager } from "./state-manager";
-import { TrackedWebSocket } from "./tracked-websocket";
 import { ActorTracesDriver } from "./traces-driver";
+import { TrackedWebSocket } from "./tracked-websocket";
 import { WriteCollector } from "./write-collector";
 
 export type { SaveStateOptions };
@@ -215,14 +207,14 @@ const ACTIVE_ASYNC_REGION_ERROR_MESSAGES: Record<
  * only on `ActorInstance`.
  */
 export interface BaseActorInstance<
-	S = any,
-	CP = any,
-	CS = any,
-	V = any,
-	I = any,
-	DB extends AnyDatabaseProvider = AnyDatabaseProvider,
-	E extends EventSchemaConfig = Record<never, never>,
-	Q extends QueueSchemaConfig = Record<never, never>,
+	_S = any,
+	_CP = any,
+	_CS = any,
+	_V = any,
+	_I = any,
+	_DB extends AnyDatabaseProvider = AnyDatabaseProvider,
+	_E extends EventSchemaConfig = Record<never, never>,
+	_Q extends QueueSchemaConfig = Record<never, never>,
 > {
 	readonly id: string;
 	readonly isStopping: boolean;
@@ -1274,7 +1266,7 @@ export class ActorInstance<
 							"actor.onBeforeActionResponse",
 							{ "rivet.action.name": actionName },
 							() =>
-								this.#config.onBeforeActionResponse!(
+								this.#config.onBeforeActionResponse?.(
 									this.actorContext,
 									actionName,
 									args,
@@ -1406,7 +1398,7 @@ export class ActorInstance<
 
 			// NOTE: This is async and will run in the background
 			const voidOrPromise = this.#traces.withSpan(span, () =>
-				this.#config.onWebSocket!(ctx, trackedWebSocket),
+				this.#config.onWebSocket?.(ctx, trackedWebSocket),
 			);
 
 			// Save changes from the WebSocket open
@@ -1882,7 +1874,7 @@ export class ActorInstance<
 				"actor.createVars",
 				undefined,
 				() => {
-					const dataOrPromise = createVars!(
+					const dataOrPromise = createVars?.(
 						this.actorContext as any,
 						this.driver.getContext(this.#actorId),
 					);
@@ -2084,7 +2076,7 @@ export class ActorInstance<
 		}
 	}
 
-	async #setupDatabase(preload?: PreloadMap) {
+	async #setupDatabase(_preload?: PreloadMap) {
 		if (!("db" in this.#config) || !this.#config.db) {
 			return;
 		}
@@ -2099,14 +2091,14 @@ export class ActorInstance<
 					overrideRawDatabaseClient: this.driver
 						.overrideRawDatabaseClient
 						? () =>
-								this.driver.overrideRawDatabaseClient!(
+								this.driver.overrideRawDatabaseClient?.(
 									this.#actorId,
 								)
 						: undefined,
 					overrideDrizzleDatabaseClient: this.driver
 						.overrideDrizzleDatabaseClient
 						? () =>
-								this.driver.overrideDrizzleDatabaseClient!(
+								this.driver.overrideDrizzleDatabaseClient?.(
 									this.#actorId,
 								)
 						: undefined,

package/src/actor/keys.ts

@@ -135,7 +135,7 @@ export function deserializeActorKey(keyString: string | undefined): ActorKey {
 	// Add the last part
 	if (escaping) {
 		// Incomplete escape at the end - treat as literal backslash
-		parts.push(currentPart + "\\");
+		parts.push(`${currentPart}\\`);
 	} else if (isEmptyStringMarker) {
 		parts.push("");
 	} else if (currentPart !== "" || parts.length > 0) {

package/src/actor/mod.ts

@@ -14,6 +14,26 @@ export type {
 	UniversalWebSocket,
 } from "@/common/websocket-interface";
 export type * from "./config";
+export type {
+	ActionContextOf,
+	BeforeActionResponseContextOf,
+	BeforeConnectContextOf,
+	ConnContextOf,
+	ConnectContextOf,
+	ConnInitContextOf,
+	CreateConnStateContextOf,
+	CreateContextOf,
+	CreateVarsContextOf,
+	DestroyContextOf,
+	DisconnectContextOf,
+	MigrateContextOf,
+	RequestContextOf,
+	RunContextOf,
+	SleepContextOf,
+	StateChangeContextOf,
+	WakeContextOf,
+	WebSocketContextOf,
+} from "./contexts";
 export type {
 	AnyActorDefinition,
 	AnyActorInstance,
@@ -35,24 +55,4 @@ export {
 	UserError,
 	type UserErrorOptions,
 } from "./errors";
-export type {
-	ActionContextOf,
-	BeforeActionResponseContextOf,
-	BeforeConnectContextOf,
-	ConnectContextOf,
-	ConnContextOf,
-	ConnInitContextOf,
-	CreateConnStateContextOf,
-	CreateContextOf,
-	CreateVarsContextOf,
-	DestroyContextOf,
-	DisconnectContextOf,
-	MigrateContextOf,
-	RequestContextOf,
-	RunContextOf,
-	SleepContextOf,
-	StateChangeContextOf,
-	WakeContextOf,
-	WebSocketContextOf,
-} from "./contexts";
 export { event, queue, type Type } from "./schema";

package/src/actor/schema.ts

@@ -69,7 +69,7 @@ export type EventSchemaConfig<TContext = any> = Record<
 	string,
 	EventSchema<TContext>
 >;
-export type QueueSchemaConfig<TContext = any> = Record<string, QueueSchema>;
+export type QueueSchemaConfig<_TContext = any> = Record<string, QueueSchema>;
 export type AnySchemaConfig = EventSchemaConfig | QueueSchemaConfig;
 
 /** @deprecated Use `EventSchema` or `QueueSchema`. */
@@ -155,7 +155,7 @@ export function hasSchemaConfigKey<T extends AnySchemaConfig>(
 	if (!schemas) {
 		return false;
 	}
-	return Object.prototype.hasOwnProperty.call(schemas, key);
+	return Object.hasOwn(schemas, key);
 }
 
 export function getEventCanSubscribe<TContext = any>(

package/src/agent-os/actor/index.ts

@@ -1,8 +1,7 @@
-import { AgentOs, createInMemoryFileSystem } from "@rivet-dev/agent-os-core";
 import type { AgentOsOptions, MountConfig } from "@rivet-dev/agent-os-core";
-import type { DatabaseProvider } from "@/common/database/config";
-import { actor, event } from "@/actor/mod";
-import type { RawAccess } from "@/common/database/config";
+import { AgentOs, createInMemoryFileSystem } from "@rivet-dev/agent-os-core";
+import { actor, event, type ActorDefinition } from "@/actor/mod";
+import type { DatabaseProvider, RawAccess } from "@/common/database/config";
 import { db } from "@/common/database/mod";
 import {
 	type AgentOsActorConfig,
@@ -141,10 +140,41 @@ function runHook<TConnParams>(
 
 export function agentOs<TConnParams = undefined>(
 	config: AgentOsActorConfigInput<TConnParams>,
-) {
+): ActorDefinition<
+	AgentOsActorState,
+	TConnParams,
+	undefined,
+	AgentOsActorVars,
+	undefined,
+	DatabaseProvider<RawAccess>,
+	{
+		sessionEvent: typeof sessionEventToken;
+		permissionRequest: typeof permissionRequestToken;
+		vmBooted: typeof vmBootedToken;
+		vmShutdown: typeof vmShutdownToken;
+		processOutput: typeof processOutputToken;
+		processExit: typeof processExitToken;
+		shellData: typeof shellDataToken;
+		cronEvent: typeof cronEventToken;
+	},
+	Record<never, never>,
+	any
+> {
 	const parsedConfig = agentOsActorConfigSchema.parse(
 		config,
 	) as AgentOsActorConfig<TConnParams>;
+	const actions = {
+		...buildSessionActions(parsedConfig),
+		...buildPromptActions(parsedConfig),
+		...buildConfigActions(parsedConfig),
+		...buildSessionPersistenceActions(parsedConfig),
+		...buildProcessActions(parsedConfig),
+		...buildFilesystemActions(parsedConfig),
+		...buildPreviewActions(parsedConfig),
+		...buildShellActions(parsedConfig),
+		...buildCronActions(parsedConfig),
+		...buildNetworkActions(parsedConfig),
+	};
 
 	return actor<
 		AgentOsActorState,
@@ -163,7 +193,8 @@ export function agentOs<TConnParams = undefined>(
 			shellData: typeof shellDataToken;
 			cronEvent: typeof cronEventToken;
 		},
-		Record<never, never>
+		Record<never, never>,
+		typeof actions
 	>({
 		options: {
 			sleepGracePeriod: 900_000,
@@ -236,18 +267,7 @@ export function agentOs<TConnParams = undefined>(
 
 			c.broadcast("vmShutdown", { reason: "destroy" as const });
 		},
-		actions: {
-			...buildSessionActions(parsedConfig),
-			...buildPromptActions(parsedConfig),
-			...buildConfigActions(parsedConfig),
-			...buildSessionPersistenceActions(parsedConfig),
-			...buildProcessActions(parsedConfig),
-			...buildFilesystemActions(parsedConfig),
-			...buildPreviewActions(parsedConfig),
-			...buildShellActions(parsedConfig),
-			...buildCronActions(parsedConfig),
-			...buildNetworkActions(parsedConfig),
-		},
+		actions,
 	});
 }
 

package/src/agent-os/actor/preview.ts

@@ -1,7 +1,6 @@
 import crypto from "node:crypto";
-import type { DatabaseProvider } from "@/common/database/config";
 import type { RequestContext } from "@/actor/config";
-import type { RawAccess } from "@/common/database/config";
+import type { DatabaseProvider, RawAccess } from "@/common/database/config";
 import type { AgentOsActorConfig } from "../config";
 import type {
 	AgentOsActionContext,

package/src/agent-os/actor/session.ts

@@ -140,11 +140,11 @@ export function subscribeToSession<TConnParams>(
 		);
 
 		// Persist event to SQLite for sleep/wake recovery.
-		persistSessionEvent(c, sessionId, event).catch((err) =>
+		persistSessionEvent(c, sessionId, event).catch((error) =>
 			c.log.error({
 				msg: "agent-os failed to persist session event",
 				sessionId,
-				error: err,
+				error,
 			}),
 		);
 

package/src/agent-os/config.ts

@@ -3,8 +3,8 @@ import type {
 	JsonRpcNotification,
 	PermissionRequest,
 } from "@rivet-dev/agent-os-core";
-import type { ActorContext, BeforeConnectContext } from "@/actor/config";
 import { z } from "zod/v4";
+import type { ActorContext, BeforeConnectContext } from "@/actor/config";
 import type { AgentOsActorState, AgentOsActorVars } from "./types";
 
 const zFunction = <

package/src/agent-os/fs/database-vfs.ts

@@ -497,7 +497,7 @@ export function createDatabaseVfs(
 			return backend.stat(p);
 		},
 
-		async link(oldPath: string, newPath: string): Promise<void> {
+		async link(_oldPath: string, _newPath: string): Promise<void> {
 			throwENOSYS("link");
 		},
 

package/src/agent-os/index.ts

@@ -1,14 +1,18 @@
 // Database migration
+
+// Cron actions
+export { buildCronActions } from "./actor/cron";
 export { migrateAgentOsTables } from "./actor/db";
-// Database-backed VFS
-export {
-	createDatabaseVfs,
-	type DatabaseVfsOptions,
-} from "./fs/database-vfs";
 // Filesystem actions
 export { buildFilesystemActions } from "./actor/filesystem";
 // Actor factory and VM lifecycle helpers
 export { agentOs, ensureVm, runHook, syncPreventSleep } from "./actor/index";
+// Network actions
+export {
+	buildNetworkActions,
+	type VmFetchOptions,
+	type VmFetchResult,
+} from "./actor/network";
 // Preview actions
 export {
 	buildOnRequestHandler,
@@ -27,20 +31,17 @@ export {
 } from "./actor/session";
 // Shell actions
 export { buildShellActions } from "./actor/shell";
-// Cron actions
-export { buildCronActions } from "./actor/cron";
-// Network actions
-export {
-	buildNetworkActions,
-	type VmFetchOptions,
-	type VmFetchResult,
-} from "./actor/network";
 // Config schema and types
 export {
 	type AgentOsActorConfig,
 	type AgentOsActorConfigInput,
 	agentOsActorConfigSchema,
 } from "./config";
+// Database-backed VFS
+export {
+	createDatabaseVfs,
+	type DatabaseVfsOptions,
+} from "./fs/database-vfs";
 // Domain types and event payloads
 export type {
 	AgentOsActionContext,
@@ -48,12 +49,12 @@ export type {
 	AgentOsActorVars,
 	AgentOsEvents,
 	CronEventPayload,
+	PermissionRequestPayload,
 	PersistedSessionEvent,
 	PersistedSessionRecord,
-	PermissionRequestPayload,
-	PromptResult,
 	ProcessExitPayload,
 	ProcessOutputPayload,
+	PromptResult,
 	SerializableCronAction,
 	SerializableCronJobOptions,
 	SessionEventPayload,

package/src/client/actor-common.ts

@@ -1,6 +1,6 @@
 import type {
-	BaseActorDefinition,
 	AnyActorDefinition,
+	BaseActorDefinition,
 } from "@/actor/definition";
 import type {
 	EventSchemaConfig,
@@ -31,6 +31,13 @@ export type ActorActionFunction<
 	...args: Args extends [unknown, ...infer Rest] ? Rest : Args
 ) => Promise<Response>;
 
+type IsAny<T> = 0 extends 1 & T ? true : false;
+
+type LooseEventSubscribe = (
+	eventName: string,
+	callback: (...args: any[]) => void,
+) => () => void;
+
 export interface ActorGatewayOptions {
 	skipReadyWait?: boolean;
 }
@@ -41,7 +48,8 @@ export function resolveActorGatewayOptions(
 	defaults: ActorGatewayOptions = {},
 	overrides?: ActorGatewayOptions,
 ): ResolvedActorGatewayOptions {
-	const skipReadyWait = overrides?.skipReadyWait ?? defaults.skipReadyWait ?? false;
+	const skipReadyWait =
+		overrides?.skipReadyWait ?? defaults.skipReadyWait ?? false;
 
 	return {
 		skipReadyWait,
@@ -63,25 +71,35 @@ export type ActorWebSocketOptions = ActorGatewayOptions;
  */
 export type ActorDefinitionActions<AD extends AnyActorDefinition> =
 	// biome-ignore lint/suspicious/noExplicitAny: safe to use any here
-	AD extends BaseActorDefinition<
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		infer R
-	>
-		? {
-				[K in keyof R]: R[K] extends (
-					...args: infer Args
-				) => infer Return
-					? ActorActionFunction<Args, Return>
-					: never;
-			}
-		: never;
+	IsAny<AD> extends true
+		? Record<string, ActorActionFunction<any[], any>>
+		: AD extends { config: { actions?: infer R } }
+			? {
+					[K in keyof R]: R[K] extends (
+						...args: infer Args
+					) => infer Return
+						? ActorActionFunction<Args, Return>
+						: never;
+				}
+			: AD extends BaseActorDefinition<
+						any,
+						any,
+						any,
+						any,
+						any,
+						any,
+						any,
+						any,
+						infer R
+					>
+				? {
+						[K in keyof R]: R[K] extends (
+							...args: infer Args
+						) => infer Return
+							? ActorActionFunction<Args, Return>
+							: never;
+					}
+				: {};
 
 type ActorQueueSend<TQueues extends QueueSchemaConfig> = {
 	<K extends keyof TQueues & string>(
@@ -119,39 +137,57 @@ type ActorEventSubscribe<TEvents extends EventSchemaConfig> = {
 
 export type ActorDefinitionQueueSend<AD extends AnyActorDefinition> =
 	// biome-ignore lint/suspicious/noExplicitAny: safe to use any here
-	AD extends BaseActorDefinition<
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		infer Q,
-		any
-	>
-		? Q extends QueueSchemaConfig
-			? { send: ActorQueueSend<Q> }
-			: never
-		: never;
+	IsAny<AD> extends true
+		? { send: ActorQueueSend<Record<string, any>> }
+		: AD extends { config: { queues?: infer Q } }
+			? Q extends QueueSchemaConfig
+				? { send: ActorQueueSend<Q> }
+				: {}
+			: AD extends BaseActorDefinition<
+						any,
+						any,
+						any,
+						any,
+						any,
+						any,
+						any,
+						infer Q,
+						any
+					>
+				? Q extends QueueSchemaConfig
+					? { send: ActorQueueSend<Q> }
+					: {}
+				: {};
 
 export type ActorDefinitionEventSubscriptions<AD extends AnyActorDefinition> =
 	// biome-ignore lint/suspicious/noExplicitAny: safe to use any here
-	AD extends BaseActorDefinition<
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		infer E,
-		any,
-		any
-	>
-		? E extends EventSchemaConfig
-			? {
-					on: ActorEventSubscribe<E>;
-					once: ActorEventSubscribe<E>;
-				}
-			: never
-		: never;
+	IsAny<AD> extends true
+		? {
+				on: LooseEventSubscribe;
+				once: LooseEventSubscribe;
+			}
+		: AD extends { config: { events?: infer E } }
+			? E extends EventSchemaConfig
+				? {
+						on: ActorEventSubscribe<E>;
+						once: ActorEventSubscribe<E>;
+					}
+				: {}
+			: AD extends BaseActorDefinition<
+						any,
+						any,
+						any,
+						any,
+						any,
+						any,
+						infer E,
+						any,
+						any
+					>
+				? E extends EventSchemaConfig
+					? {
+							on: ActorEventSubscribe<E>;
+							once: ActorEventSubscribe<E>;
+						}
+					: {}
+				: {};

package/src/client/actor-conn.ts

@@ -14,6 +14,7 @@ import {
 	type ToServer as ToServerJson,
 	ToServerSchema,
 } from "@/common/client-protocol-zod";
+import type { JsonCompatValue } from "@/common/encoding";
 import {
 	type Encoding,
 	inputDataToBuffer,
@@ -93,8 +94,6 @@ interface EventSubscriptions<Args extends Array<unknown>> {
 	once: boolean;
 }
 
-const DEFAULT_MAX_INCOMING_MESSAGE_SIZE = 65_536;
-
 /**
  * A function that unsubscribes from an event.
  *
@@ -785,12 +784,10 @@ export class ActorConnRaw {
 				}
 
 				// Check if this is an actor scheduling error and try to get more details
-				let errorToThrow = new errors.ActorError(
-					group,
-					code,
-					message,
-					{ metadata, actor },
-				);
+				let errorToThrow = new errors.ActorError(group, code, message, {
+					metadata,
+					actor,
+				});
 				if (errors.isSchedulingError(group, code) && this.#actorId) {
 					const schedulingError = await checkForSchedulingError(
 						group,
@@ -1272,7 +1269,8 @@ export class ActorConnRaw {
 											name: msg.body.val.name,
 											args: bufferToArrayBuffer(
 												encodeCborCompat(
-													msg.body.val.args,
+													msg.body.val
+														.args as JsonCompatValue,
 												),
 											),
 										},
@@ -1283,34 +1281,8 @@ export class ActorConnRaw {
 							}
 						},
 					);
-					const serializedLength = messageLength(messageSerialized);
-					if (
-						serializedLength > DEFAULT_MAX_INCOMING_MESSAGE_SIZE &&
-						message.body.tag === "ActionRequest"
-					) {
-						const actionId = Number(message.body.val.id);
-						const inFlight = this.#takeActionInFlight(actionId);
-						const error = new errors.ActorError(
-							"message",
-							"incoming_too_long",
-							"Incoming message too long",
-							{
-								maxSize: DEFAULT_MAX_INCOMING_MESSAGE_SIZE,
-								actualSize: serializedLength,
-							},
-						);
-						logger().warn({
-							msg: "rejecting oversized connection action request",
-							actionId,
-							actionName: inFlight.name,
-							actualSize: serializedLength,
-							maxSize: DEFAULT_MAX_INCOMING_MESSAGE_SIZE,
-						});
-						inFlight.reject(error);
-						this.#dispatchActorError(error);
-						return;
-					}
 					this.#websocket.send(messageSerialized);
+					const serializedLength = messageLength(messageSerialized);
 					logger().trace({
 						msg: "sent websocket message",
 						len: serializedLength,