rivetkit 2.3.0-rc.9 → 2.3.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,
@@ -32,27 +52,9 @@ export {
 export {
 	ActorError,
 	RivetError,
+	type RivetErrorLike,
+	type RivetErrorOptions,
 	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,36 @@ 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;
+
+type ActorActionMap<R> = {
+	[K in keyof NonNullable<R>]: NonNullable<R>[K] extends (
+		...args: infer Args
+	) => infer Return
+		? ActorActionFunction<Args, Awaited<Return>>
+		: never;
+};
+
+type ActionsOf<AD extends AnyActorDefinition> =
+	AD extends BaseActorDefinition<
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		infer R
+	>
+		? R
+		: never;
+
 export interface ActorGatewayOptions {
 	skipReadyWait?: boolean;
 }
@@ -41,7 +71,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 +94,9 @@ 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>>
+		: ActorActionMap<ActionsOf<AD>>;
 
 type ActorQueueSend<TQueues extends QueueSchemaConfig> = {
 	<K extends keyof TQueues & string>(
@@ -119,39 +134,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,