fix(rivetkit): preserve internal bridge errors

Author: NathanFlurry

rivetkit-rust/packages/rivetkit-core/src/actor/action.rs

@@ -1,4 +1,4 @@
-use rivet_error::{MacroMarker, RivetError, RivetErrorSchema};
+use rivet_error::{INTERNAL_ERROR, MacroMarker, RivetError, RivetErrorSchema};
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 
@@ -12,30 +12,62 @@ pub struct ActionDispatchError {
 
 impl ActionDispatchError {
 	pub(crate) fn from_anyhow(error: anyhow::Error) -> Self {
+		let original_message = error.to_string();
 		let error = RivetError::extract(&error);
+		let message = if is_internal_error(error.group(), error.code()) {
+			original_message
+		} else {
+			error.message().to_owned()
+		};
 		Self {
 			group: error.group().to_owned(),
 			code: error.code().to_owned(),
-			message: error.message().to_owned(),
+			message,
 			metadata: error.metadata(),
 		}
 	}
 
+	pub(crate) fn client_message(&self) -> &str {
+		if is_internal_error(&self.group, &self.code) {
+			INTERNAL_ERROR.default_message
+		} else {
+			&self.message
+		}
+	}
+
+	pub(crate) fn client_metadata(&self) -> Option<&JsonValue> {
+		if is_internal_error(&self.group, &self.code) {
+			None
+		} else {
+			self.metadata.as_ref()
+		}
+	}
+
 	pub(crate) fn into_anyhow(self) -> anyhow::Error {
+		let message = self.client_message().to_owned();
 		let meta = self
-			.metadata
-			.and_then(|value| serde_json::value::to_raw_value(&value).ok());
+			.client_metadata()
+			.and_then(|value| serde_json::value::to_raw_value(value).ok());
 		let schema = Box::leak(Box::new(RivetErrorSchema {
 			group: Box::leak(self.group.into_boxed_str()),
 			code: Box::leak(self.code.into_boxed_str()),
-			default_message: Box::leak(self.message.clone().into_boxed_str()),
+			default_message: Box::leak(message.clone().into_boxed_str()),
 			meta_type: None,
 			_macro_marker: MacroMarker { _private: () },
 		}));
 		anyhow::Error::new(RivetError {
 			schema,
 			meta,
-			message: Some(self.message),
+			message: Some(message),
 		})
 	}
 }
+
+fn is_internal_error(group: &str, code: &str) -> bool {
+	(group == "core" || group == "rivetkit") && code == "internal_error"
+}
+
+// Test shim keeps moved tests under tests while retaining private module access.
+#[cfg(test)]
+#[path = "../../tests/modules/action_dispatch_error.rs"]
+mod tests;

rivetkit-rust/packages/rivetkit-core/src/registry/actor_connect.rs

@@ -426,13 +426,13 @@ pub(super) fn action_dispatch_error_response(
 	action_id: u64,
 ) -> ActorConnectError {
 	let metadata = error
-		.metadata
-		.as_ref()
+		.client_metadata()
 		.and_then(|metadata| encode_json_as_cbor(metadata).ok().map(ByteBuf::from));
+	let message = error.client_message().to_owned();
 	ActorConnectError {
 		group: error.group,
 		code: error.code,
-		message: error.message,
+		message,
 		metadata,
 		action_id: Some(action_id),
 	}

rivetkit-rust/packages/rivetkit-core/src/registry/http.rs

@@ -905,8 +905,8 @@ pub(super) fn framework_action_error_response(
 			encoding,
 			&error.group,
 			&error.code,
-			&error.message,
-			error.metadata.as_ref(),
+			error.client_message(),
+			error.client_metadata(),
 		)?),
 		body_stream: None,
 	})

rivetkit-rust/packages/rivetkit-core/src/registry/inspector.rs

@@ -655,7 +655,7 @@ pub(super) fn action_error_response(error: ActionDispatchError) -> HttpResponse
 	} else {
 		StatusCode::INTERNAL_SERVER_ERROR
 	};
-	inspector_error_response(status, &error.group, &error.code, &error.message)
+	inspector_error_response(status, &error.group, &error.code, error.client_message())
 }
 
 pub(super) fn inspector_anyhow_response(error: anyhow::Error) -> HttpResponse {

rivetkit-rust/packages/rivetkit-core/tests/modules/action.rs

@@ -152,6 +152,7 @@ mod moved_tests {
 				group: "actor".to_owned(),
 				code: "action_not_found".to_owned(),
 				message: "action `missing` was not found".to_owned(),
+				metadata: None,
 			}
 		);
 	}
@@ -188,11 +189,11 @@ mod moved_tests {
 	}
 
 	#[tokio::test]
-	async fn dispatch_extracts_group_code_and_message_from_anyhow_errors() {
+	async fn dispatch_preserves_internal_anyhow_message_until_client_boundary() {
 		let mut callbacks = ActorInstanceCallbacks::default();
 		callbacks.actions.insert(
 			"explode".to_owned(),
-			action_handler(|_| Box::pin(async move { Err(INTERNAL_ERROR.build()) })),
+			action_handler(|_| Box::pin(async move { Err(anyhow::anyhow!("plain failure")) })),
 		);
 
 		let invoker = ActionInvoker::new(ActorConfig::default(), callbacks);
@@ -203,7 +204,8 @@ mod moved_tests {
 
 		assert_eq!(error.group, "core");
 		assert_eq!(error.code, "internal_error");
-		assert_eq!(error.message, "An internal error occurred");
+		assert_eq!(error.message, "plain failure");
+		assert_eq!(error.client_message(), "An internal error occurred");
 	}
 
 	#[tokio::test]

rivetkit-rust/packages/rivetkit-core/tests/modules/action_dispatch_error.rs

@@ -0,0 +1,29 @@
+use super::*;
+
+#[test]
+fn preserves_internal_anyhow_message_until_client_boundary() {
+	let error = ActionDispatchError::from_anyhow(anyhow::anyhow!("plain failure"));
+
+	assert_eq!(error.group, "core");
+	assert_eq!(error.code, "internal_error");
+	assert_eq!(error.message, "plain failure");
+	assert_eq!(error.client_message(), "An internal error occurred");
+	assert_eq!(error.client_metadata(), None);
+}
+
+#[test]
+fn preserves_public_error_message_for_client_boundary() {
+	static TEST_ERROR: RivetErrorSchema = RivetErrorSchema {
+		group: "actor",
+		code: "action_not_found",
+		default_message: "action `missing` was not found",
+		meta_type: None,
+		_macro_marker: MacroMarker { _private: () },
+	};
+	let error = ActionDispatchError::from_anyhow(TEST_ERROR.build());
+
+	assert_eq!(error.group, "actor");
+	assert_eq!(error.code, "action_not_found");
+	assert_eq!(error.message, "action `missing` was not found");
+	assert_eq!(error.client_message(), "action `missing` was not found");
+}

rivetkit-rust/packages/rivetkit-core/tests/modules/registry_http.rs

@@ -195,6 +195,33 @@ fn framework_action_error_response_maps_timeout_to_408() {
 	);
 }
 
+#[test]
+fn framework_action_error_response_sanitizes_internal_message() {
+	let response = framework_action_error_response(
+		HttpResponseEncoding::Json,
+		ActionDispatchError {
+			group: "rivetkit".to_owned(),
+			code: "internal_error".to_owned(),
+			message: "plain failure".to_owned(),
+			metadata: Some(json!({ "error": "plain failure" })),
+		},
+	)
+	.expect("internal error response should serialize");
+
+	assert_eq!(response.status, StatusCode::INTERNAL_SERVER_ERROR.as_u16());
+	assert_eq!(
+		response.body,
+		Some(
+			serde_json::to_vec(&json!({
+				"group": "rivetkit",
+				"code": "internal_error",
+				"message": "An internal error occurred",
+			}))
+			.expect("json body should encode")
+		)
+	);
+}
+
 #[test]
 fn message_boundary_error_response_defaults_to_json() {
 	let response = message_boundary_error_response(

rivetkit-rust/packages/rivetkit-core/tests/registry_http.rs

@@ -154,6 +154,33 @@ mod moved_tests {
 		);
 	}
 
+	#[test]
+	fn framework_action_error_response_sanitizes_internal_message() {
+		let response = framework_action_error_response(
+			HttpResponseEncoding::Json,
+			ActionDispatchError {
+				group: "rivetkit".to_owned(),
+				code: "internal_error".to_owned(),
+				message: "plain failure".to_owned(),
+				metadata: Some(json!({ "error": "plain failure" })),
+			},
+		)
+		.expect("internal error response should serialize");
+
+		assert_eq!(response.status, StatusCode::INTERNAL_SERVER_ERROR.as_u16());
+		assert_eq!(
+			response.body,
+			Some(
+				serde_json::to_vec(&json!({
+					"group": "rivetkit",
+					"code": "internal_error",
+					"message": "An internal error occurred",
+				}))
+				.expect("json body should encode")
+			)
+		);
+	}
+
 	#[test]
 	fn message_boundary_error_response_defaults_to_json() {
 		let response = message_boundary_error_response(

rivetkit-typescript/packages/rivetkit-napi/src/actor_factory.rs

@@ -1033,16 +1033,13 @@ pub(crate) fn callback_error(callback_name: &str, error: napi::Error) -> anyhow:
 		.build();
 	}
 
-	tracing::debug!(
+	tracing::warn!(
 		callback = callback_name,
 		status = ?error.status,
+		reason,
 		"napi callback failed without structured bridge error prefix"
 	);
-	JsCallbackUnavailable {
-		callback: callback_name.to_owned(),
-		reason,
-	}
-	.build()
+	anyhow::anyhow!(reason)
 }
 
 impl From<JsActorConfig> for ActorConfigInput {

rivetkit-typescript/packages/rivetkit/src/registry/native.ts

@@ -670,9 +670,14 @@ function isStructuredBridgeError(
 function encodeNativeCallbackError(error: unknown): Error {
 	const structuredError = isStructuredBridgeError(error)
 		? error
-		: deconstructError(error, logger(), {
+		: deconstructError(
+			error,
+			logger(),
+			{
 				bridge: "native_callback",
-			});
+			},
+			true,
+		);
 	let stack: string | undefined;
 	if (error instanceof Error) {
 		try {