chore: fix serverless in rivetkit-core

Author: NathanFlurry

Cargo.lock

@@ -63,6 +63,7 @@ members = [
   "rivetkit-rust/packages/inspector-protocol",
   "rivetkit-rust/packages/rivetkit",
   "rivetkit-rust/packages/rivetkit-core",
+  "rivetkit-rust/packages/shared-types",
   "rivetkit-rust/packages/rivetkit-sqlite",
   "rivetkit-typescript/packages/rivetkit-napi"
 ]
@@ -540,6 +541,9 @@ members = [
     [workspace.dependencies.rivetkit-core]
     path = "rivetkit-rust/packages/rivetkit-core"
 
+    [workspace.dependencies.rivetkit-shared-types]
+    path = "rivetkit-rust/packages/shared-types"
+
     [workspace.dependencies.epoxy-protocol]
     path = "engine/sdks/rust/epoxy-protocol"
 

Cargo.toml

@@ -32,6 +32,7 @@ rivet-runner-protocol.workspace = true
 rivet-runtime.workspace = true
 rivet-types.workspace = true
 rivet-util.workspace = true
+rivetkit-shared-types.workspace = true
 serde_bare.workspace = true
 serde_json.workspace = true
 serde.workspace = true

engine/packages/pegboard/Cargo.toml

@@ -5,6 +5,7 @@ use anyhow::Result;
 use gas::prelude::*;
 use reqwest::header::{HeaderMap as ReqwestHeaderMap, HeaderName, HeaderValue};
 use rivet_envoy_protocol::PROTOCOL_VERSION;
+use rivetkit_shared_types::serverless_metadata::{ActorName, ServerlessMetadataPayload};
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
@@ -25,8 +26,9 @@ pub enum ServerlessMetadataError {
 	RequestFailed {},
 	RequestTimedOut {},
 	NonSuccessStatus { status_code: u16, body: String },
-	InvalidResponseJson { body: String },
+	InvalidResponseJson { body: String, parse_error: String },
 	InvalidResponseSchema { runtime: String, version: String },
+	InvalidEnvoyProtocolVersion { version: u16 },
 }
 
 #[derive(Debug, Clone)]
@@ -45,33 +47,6 @@ pub struct ActorNameMetadata {
 	pub metadata: serde_json::Map<String, serde_json::Value>,
 }
 
-#[derive(Deserialize)]
-struct ServerlessMetadataEnvoy {
-	version: Option<u32>,
-}
-
-#[derive(Deserialize)]
-struct ServerlessMetadataRunner {
-	version: Option<u32>,
-}
-
-#[derive(Deserialize)]
-struct ServerlessMetadataPayload {
-	runtime: String,
-	version: String,
-	#[serde(rename = "envoyProtocolVersion")]
-	envoy_protocol_version: Option<u16>,
-	#[serde(rename = "actorNames", default)]
-	actor_names: HashMap<String, ActorName>,
-	envoy: Option<ServerlessMetadataEnvoy>,
-	runner: Option<ServerlessMetadataRunner>,
-}
-
-#[derive(Deserialize)]
-struct ActorName {
-	metadata: Option<serde_json::Value>,
-}
-
 fn truncate_response_body(body: &str) -> String {
 	let mut chars = body.chars();
 	let mut truncated: String = chars.by_ref().take(RESPONSE_BODY_MAX_LEN).collect();
@@ -160,9 +135,10 @@ pub async fn pegboard_serverless_metadata_fetch(
 
 	let payload = match serde_json::from_str::<ServerlessMetadataPayload>(&body_raw) {
 		Ok(p) => p,
-		Err(_) => {
+		Err(err) => {
 			return Ok(Err(ServerlessMetadataError::InvalidResponseJson {
 				body: body_for_user,
+				parse_error: err.to_string(),
 			}));
 		}
 	};
@@ -197,8 +173,8 @@ pub async fn pegboard_serverless_metadata_fetch(
 
 	if let Some(envoy_protocol_version) = envoy_protocol_version {
 		if envoy_protocol_version < 1 || envoy_protocol_version > PROTOCOL_VERSION {
-			return Ok(Err(ServerlessMetadataError::InvalidResponseJson {
-				body: body_for_user,
+			return Ok(Err(ServerlessMetadataError::InvalidEnvoyProtocolVersion {
+				version: envoy_protocol_version,
 			}));
 		}
 	}

engine/packages/pegboard/src/ops/serverless_metadata/fetch.rs

@@ -23,6 +23,7 @@ rivet-pools.workspace = true
 rivet-util.workspace = true
 rivet-error.workspace = true
 rivet-envoy-client.workspace = true
+rivetkit-shared-types.workspace = true
 rivetkit-client-protocol.workspace = true
 rivetkit-inspector-protocol.workspace = true
 rivetkit-sqlite = { workspace = true, optional = true }

examples/kitchen-sink/package.json

@@ -9,6 +9,9 @@ use rivet_envoy_client::config::EnvoyConfig;
 use rivet_envoy_client::envoy::start_envoy;
 use rivet_envoy_client::handle::EnvoyHandle;
 use rivet_envoy_client::protocol;
+use rivetkit_shared_types::serverless_metadata::{
+	ActorName, ServerlessMetadataEnvoy, ServerlessMetadataPayload,
+};
 use serde::Serialize;
 use serde_json::json;
 use subtle::ConstantTimeEq;
@@ -308,22 +311,38 @@ impl CoreServerlessRuntime {
 						],
 					}),
 				);
-				(actor_name.clone(), json!({ "metadata": metadata }))
+				(
+					actor_name.clone(),
+					ActorName {
+						metadata: Some(serde_json::Value::Object(metadata)),
+					},
+				)
 			})
-			.collect::<serde_json::Map<_, _>>();
-
-		let mut response = json!({
-			"runtime": "rivetkit",
-			"version": self.settings.package_version,
-			"envoy": {
-				"kind": { "serverless": {} },
-				"version": self.settings.version,
-			},
-			"envoyProtocolVersion": protocol::PROTOCOL_VERSION,
-			"actorNames": actor_names,
-		});
+			.collect::<HashMap<_, _>>();
+
+		let payload = ServerlessMetadataPayload {
+			runtime: "rivetkit".to_owned(),
+			version: self.settings.package_version.clone(),
+			envoy_protocol_version: Some(protocol::PROTOCOL_VERSION),
+			actor_names,
+			envoy: Some(ServerlessMetadataEnvoy {
+				version: Some(self.settings.version),
+			}),
+			runner: None,
+		};
+
+		let mut response = serde_json::to_value(payload).unwrap_or_else(|_| json!({}));
 
 		if let serde_json::Value::Object(object) = &mut response {
+			if object.get("runner").is_some_and(serde_json::Value::is_null) {
+				object.remove("runner");
+			}
+			if let Some(envoy) = object
+				.get_mut("envoy")
+				.and_then(|value| value.as_object_mut())
+			{
+				envoy.insert("kind".to_owned(), json!({ "serverless": {} }));
+			}
 			if let Some(client_endpoint) = &self.settings.client_endpoint {
 				object.insert("clientEndpoint".to_owned(), json!(client_endpoint));
 			}

examples/kitchen-sink/turbo.json

@@ -0,0 +1,11 @@
+[package]
+name = "rivetkit-shared-types"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+workspace = "../../../"
+
+[dependencies]
+serde.workspace = true
+serde_json.workspace = true