feat(relay): support inline Switchyard configuration

Signed-off-by: Bryan Bednarski <bbednarski@nvidia.com>

Author: bbednarski9

Cargo.lock

@@ -26,3 +26,7 @@ switchyard-protocol.workspace = true
 switchyard-runner.workspace = true
 switchyard-translation.workspace = true
 tokio.workspace = true
+toml = "1.1"
+
+[dev-dependencies]
+tempfile = "3"

crates/switchyard-nemo-relay-plugin/Cargo.toml

@@ -1,8 +1,8 @@
 # Switchyard NeMo Relay Plugin
 
 `switchyard-nemo-relay-plugin` is a native NeMo Relay dynamic plugin. It loads
-a standard Switchyard TOML deployment and executes its configured routes in
-Relay through `switchyard-runner`.
+a standard Switchyard TOML deployment from a file or Relay's nested plugin
+configuration and executes its configured routes through `switchyard-runner`.
 
 The plugin does not define a second routing or target configuration language.
 `switchyard-server` and Relay therefore use the same targets, client pooling,
@@ -16,22 +16,50 @@ the generated `relay-plugin.toml` manifest. The plugin requires NeMo Relay
 
 ## Configure Relay
 
-Point the dynamic plugin configuration at an existing Switchyard deployment:
+Use exactly one Switchyard deployment source. To share an existing deployment
+file with `switchyard-server`, configure its path:
 
 ```toml
 [[plugins.dynamic]]
-plugin_id = "nvidia.switchyard"
+manifest = "./plugins/switchyard/relay-plugin.toml"
 
 [plugins.dynamic.config]
 priority = 0
-deployment_path = "/etc/switchyard/routes.toml"
+switchyard_config_path = "/etc/switchyard/routes.toml"
 ```
 
-`deployment_path` is a Switchyard version-1 TOML deployment, accepted by both
+`switchyard_config_path` is a Switchyard version-1 TOML deployment, accepted by both
 `switchyard-server` and `switchyard-runner`. See the
 [server configuration guide](../switchyard-server/CONFIGURATION.md) for the
 deployment schema and routing algorithms.
 
+To keep the deployment in the Relay configuration, nest the same version-1
+Switchyard configuration under `switchyard_config`:
+
+```toml
+[[plugins.dynamic]]
+manifest = "./plugins/switchyard/relay-plugin.toml"
+
+[plugins.dynamic.config]
+priority = 0
+
+[plugins.dynamic.config.switchyard_config]
+schema_version = 1
+
+[plugins.dynamic.config.switchyard_config.llm_clients.primary]
+format = "openai_chat"
+base_url = "https://example.test/v1"
+
+[plugins.dynamic.config.switchyard_config.targets.default]
+id = "example/model"
+llm_client = "primary"
+
+[plugins.dynamic.config.switchyard_config.routes.default]
+id = "switchyard/default"
+type = "passthrough"
+target = "default"
+```
+
 ## Request handling
 
 For OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages calls,

crates/switchyard-nemo-relay-plugin/README.md

@@ -4,17 +4,37 @@
   "description": "Runs a Switchyard deployment through its shared in-process runner.",
   "type": "object",
   "additionalProperties": false,
-  "required": ["deployment_path"],
+  "oneOf": [
+    { "required": ["switchyard_config_path"] },
+    { "required": ["switchyard_config"] }
+  ],
   "properties": {
     "priority": {
       "type": "integer",
       "default": 0,
       "description": "NeMo Relay execution-intercept priority."
     },
-    "deployment_path": {
+    "executor": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Optional NeMo Relay SDK executor override.",
+      "properties": {
+        "worker_threads": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Number of worker threads for the plugin's SDK-owned executor."
+        }
+      }
+    },
+    "switchyard_config_path": {
       "type": "string",
       "minLength": 1,
       "description": "Path to a Switchyard version-1 TOML deployment shared with switchyard-server."
+    },
+    "switchyard_config": {
+      "type": "object",
+      "minProperties": 1,
+      "description": "Inline Switchyard version-1 deployment using the same schema as switchyard-server."
     }
   }
 }

crates/switchyard-nemo-relay-plugin/config.schema.json

@@ -4,6 +4,7 @@
 use std::path::PathBuf;
 
 use serde::Deserialize;
+use serde_json::{Map, Value};
 use switchyard_protocol::WireFormat;
 use switchyard_runner::Runner;
 
@@ -21,19 +22,66 @@ pub(crate) fn protocol_from_call(name: &str) -> Option<WireFormat> {
 pub(crate) struct SwitchyardConfig {
     #[serde(default)]
     pub(crate) priority: i32,
-    pub(crate) deployment_path: PathBuf,
+    #[serde(default)]
+    pub(crate) switchyard_config_path: Option<PathBuf>,
+    #[serde(default)]
+    pub(crate) switchyard_config: Option<Map<String, Value>>,
 }
 
 impl SwitchyardConfig {
     pub(crate) fn load_runner(&self) -> Result<Runner, String> {
-        Runner::load(&self.deployment_path).map_err(|error| error.to_string())
+        match (&self.switchyard_config_path, &self.switchyard_config) {
+            (Some(path), None) => Runner::load(path).map_err(|error| error.to_string()),
+            (None, Some(config)) => toml::to_string(config)
+                .map_err(|error| format!("failed to serialize Switchyard configuration: {error}"))
+                .and_then(|source| Runner::from_toml(&source).map_err(|error| error.to_string())),
+            (Some(_), Some(_)) => Err(
+                "configure exactly one of switchyard_config_path or switchyard_config".to_string(),
+            ),
+            (None, None) => {
+                Err("configure one of switchyard_config_path or switchyard_config".to_string())
+            }
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::io::Write;
+
+    use serde_json::json;
+    use tempfile::NamedTempFile;
+
     use super::*;
 
+    fn inline_deployment() -> Map<String, Value> {
+        json!({
+            "schema_version": 1,
+            "llm_clients": {
+                "primary": {
+                    "format": "openai_chat",
+                    "base_url": "https://example.test/v1"
+                }
+            },
+            "targets": {
+                "default": {
+                    "id": "example/model",
+                    "llm_client": "primary"
+                }
+            },
+            "routes": {
+                "default": {
+                    "id": "switchyard/default",
+                    "type": "passthrough",
+                    "target": "default"
+                }
+            }
+        })
+        .as_object()
+        .unwrap()
+        .clone()
+    }
+
     #[test]
     fn maps_supported_relay_call_names_to_wire_formats() {
         let cases = [
@@ -47,4 +95,58 @@ mod tests {
             assert_eq!(protocol_from_call(name), expected, "{name}");
         }
     }
+
+    #[test]
+    fn builds_runner_from_inline_deployment() {
+        let config = SwitchyardConfig {
+            priority: 0,
+            switchyard_config_path: None,
+            switchyard_config: Some(inline_deployment()),
+        };
+
+        let runner = config.load_runner().unwrap();
+        assert!(runner.route("switchyard/default").is_some());
+    }
+
+    #[test]
+    fn builds_runner_from_deployment_path() {
+        let mut deployment = NamedTempFile::new().unwrap();
+        write!(
+            deployment,
+            "{}",
+            toml::to_string(&inline_deployment()).unwrap()
+        )
+        .unwrap();
+        let config = SwitchyardConfig {
+            priority: 0,
+            switchyard_config_path: Some(deployment.path().to_path_buf()),
+            switchyard_config: None,
+        };
+
+        let runner = config.load_runner().unwrap();
+        assert!(runner.route("switchyard/default").is_some());
+    }
+
+    #[test]
+    fn requires_exactly_one_configuration_source() {
+        let neither = SwitchyardConfig {
+            priority: 0,
+            switchyard_config_path: None,
+            switchyard_config: None,
+        };
+        assert!(matches!(
+            neither.load_runner(),
+            Err(error) if error.contains("configure one of switchyard_config_path or switchyard_config")
+        ));
+
+        let both = SwitchyardConfig {
+            priority: 0,
+            switchyard_config_path: Some(PathBuf::from("routes.toml")),
+            switchyard_config: Some(inline_deployment()),
+        };
+        assert!(matches!(
+            both.load_runner(),
+            Err(error) if error.contains("configure exactly one of switchyard_config_path or switchyard_config")
+        ));
+    }
 }

crates/switchyard-nemo-relay-plugin/src/config.rs

@@ -122,7 +122,9 @@ fn register_stream(
 }
 
 fn parse_config(plugin_config: &Map<String, Json>) -> Result<SwitchyardConfig, String> {
-    serde_json::from_value(Json::Object(plugin_config.clone()))
+    let mut config = plugin_config.clone();
+    config.remove("executor");
+    serde_json::from_value(Json::Object(config))
         .map_err(|error| format!("invalid Switchyard configuration: {error}"))
 }
 
@@ -135,9 +137,20 @@ mod tests {
     use super::*;
 
     #[test]
-    fn plugin_configuration_requires_a_deployment_path() {
+    fn plugin_configuration_requires_a_switchyard_source() {
         let config = json!({"priority": 0});
-        let error = parse_config(config.as_object().unwrap()).unwrap_err();
-        assert!(error.contains("deployment_path"));
+        assert!(matches!(
+            parse_config(config.as_object().unwrap()).and_then(SwitchyardRuntime::new),
+            Err(error) if error.contains("switchyard_config_path or switchyard_config")
+        ));
+    }
+
+    #[test]
+    fn plugin_configuration_ignores_the_sdk_executor_override() {
+        let config = json!({
+            "executor": {"worker_threads": 4},
+            "switchyard_config_path": "routes.toml"
+        });
+        assert!(parse_config(config.as_object().unwrap()).is_ok());
     }
 }