feat: include generator metatada in model import and cli validate errors (#2452)

Closes #2433

Artificially induced error from python export:

<img width="656" height="321" alt="image"
src="https://github.com/user-attachments/assets/2a41d489-3f34-4a5c-99b0-ab31d759bf90"
/>

Author: ss2165

hugr-cli/src/lib.rs

@@ -126,4 +126,13 @@ pub enum CliError {
         "Invalid format: '{_0}'. Valid formats are: json, model, model-exts, model-text, model-text-exts"
     )]
     InvalidFormat(String),
+    #[error("Error validating HUGR generated by {generator}")]
+    /// Errors produced by the `validate` subcommand, with a known generator of the HUGR.
+    ValidateKnownGenerator {
+        #[source]
+        /// The inner validation error.
+        inner: PackageValidationError,
+        /// The generator of the HUGR.
+        generator: Box<String>,
+    },
 }

hugr-cli/src/validate.rs

@@ -29,16 +29,32 @@ impl ValArgs {
     pub fn run(&mut self) -> Result<()> {
         if self.input_args.hugr_json {
             let hugr = self.input_args.get_hugr()?;
+            let generator = hugr::envelope::get_generator(&[&hugr]);
+
             hugr.validate()
                 .map_err(PackageValidationError::Validation)
-                .map_err(CliError::Validate)?;
+                .map_err(|val_err| wrap_generator(generator, val_err))?;
         } else {
             let package = self.input_args.get_package()?;
-            package.validate().map_err(CliError::Validate)?;
+            let generator = hugr::envelope::get_generator(&package.modules);
+            package
+                .validate()
+                .map_err(|val_err| wrap_generator(generator, val_err))?;
         };
 
         info!("{VALID_PRINT}");
 
         Ok(())
     }
 }
+
+fn wrap_generator(generator: Option<String>, val_err: PackageValidationError) -> CliError {
+    if let Some(g) = generator {
+        CliError::ValidateKnownGenerator {
+            inner: val_err,
+            generator: Box::new(g.to_string()),
+        }
+    } else {
+        CliError::Validate(val_err)
+    }
+}

hugr-cli/tests/validate.rs

@@ -13,12 +13,15 @@ use hugr::types::Type;
 use hugr::{
     builder::{Container, Dataflow},
     extension::prelude::{bool_t, qb_t},
+    hugr::HugrView,
+    hugr::hugrmut::HugrMut,
     std_extensions::arithmetic::float_types::float64_type,
     types::Signature,
 };
 use hugr_cli::validate::VALID_PRINT;
 use predicates::{prelude::*, str::contains};
 use rstest::{fixture, rstest};
+use serde_json::json;
 
 #[fixture]
 fn cmd() -> Command {
@@ -123,6 +126,7 @@ fn test_mermaid_invalid(bad_hugr_string: String, mut cmd: Command) {
     cmd.write_stdin(bad_hugr_string);
     cmd.assert()
         .failure()
+        .stderr(contains("unconnected port"))
         .stderr(contains("Error validating HUGR"));
 }
 
@@ -134,6 +138,7 @@ fn test_bad_hugr(bad_hugr_string: String, mut val_cmd: Command) {
     val_cmd
         .assert()
         .failure()
+        .stderr(contains("unconnected port"))
         .stderr(contains("Error validating HUGR"));
 }
 
@@ -146,7 +151,8 @@ fn test_bad_json(mut val_cmd: Command) {
     val_cmd
         .assert()
         .failure()
-        .stderr(contains("Error decoding HUGR envelope"));
+        .stderr(contains("Error decoding HUGR envelope"))
+        .stderr(contains("missing field"));
 }
 
 #[rstest]
@@ -199,3 +205,38 @@ fn test_package_validation(package_string: String, mut val_cmd: Command) {
 
     val_cmd.assert().success().stderr(contains(VALID_PRINT));
 }
+
+/// Create a deliberately invalid HUGR with a known generator
+#[fixture]
+fn invalid_hugr_with_generator() -> Vec<u8> {
+    // Create an invalid HUGR (missing outputs in a dataflow)
+    let df = DFGBuilder::new(Signature::new_endo(vec![qb_t()])).unwrap();
+    let mut bad_hugr = df.hugr().clone(); // Missing outputs makes this invalid
+    bad_hugr.set_metadata(
+        bad_hugr.module_root(),
+        hugr::envelope::GENERATOR_KEY,
+        json!({"name": "test-generator", "version": "1.0.1"}),
+    );
+    // Create envelope with a specific generator
+    let envelope_config = EnvelopeConfig::binary();
+
+    let mut buff = Vec::new();
+    // Serialize to string
+    bad_hugr.store(&mut buff, envelope_config).unwrap();
+    buff
+}
+
+#[rstest]
+fn test_validate_known_generator(invalid_hugr_with_generator: Vec<u8>, mut val_cmd: Command) {
+    // Write the invalid HUGR to stdin
+    val_cmd.write_stdin(invalid_hugr_with_generator);
+    val_cmd.arg("-");
+
+    // Expect a failure with the generator name in the error message
+    val_cmd
+        .assert()
+        .failure()
+        .stderr(contains("Error validating HUGR"))
+        .stderr(contains("unconnected port"))
+        .stderr(contains("generated by test-generator-v1.0.1"));
+}

hugr-core/src/envelope.rs

@@ -73,11 +73,11 @@ pub const USED_EXTENSIONS_KEY: &str = "core.used_extensions";
 /// If multiple modules have different generators, a comma-separated list is returned in
 /// module order.
 /// If no generator is found, `None` is returned.
-fn get_generator<H: HugrView>(modules: &[H]) -> Option<String> {
+pub fn get_generator<H: HugrView>(modules: &[H]) -> Option<String> {
     let generators: Vec<String> = modules
         .iter()
         .filter_map(|hugr| hugr.get_metadata(hugr.module_root(), GENERATOR_KEY))
-        .map(|v| v.to_string())
+        .map(format_generator)
         .collect();
     if generators.is_empty() {
         return None;
@@ -86,6 +86,31 @@ fn get_generator<H: HugrView>(modules: &[H]) -> Option<String> {
     Some(generators.join(", "))
 }
 
+/// Format a generator value from the metadata.
+pub fn format_generator(json_val: &serde_json::Value) -> String {
+    match json_val {
+        serde_json::Value::String(s) => s.clone(),
+        serde_json::Value::Object(obj) => {
+            if let (Some(name), version) = (
+                obj.get("name").and_then(|v| v.as_str()),
+                obj.get("version").and_then(|v| v.as_str()),
+            ) {
+                if let Some(version) = version {
+                    // Expected format: {"name": "generator", "version": "1.0.0"}
+                    format!("{name}-v{version}")
+                } else {
+                    name.to_string()
+                }
+            } else {
+                // just print the whole object as a string
+                json_val.to_string()
+            }
+        }
+        // Raw JSON string fallback
+        _ => json_val.to_string(),
+    }
+}
+
 fn gen_str(generator: &Option<String>) -> String {
     match generator {
         Some(g) => format!("\ngenerated by {g}"),
@@ -280,7 +305,7 @@ pub enum EnvelopeError {
         source: hugr_model::v0::binary::WriteError,
     },
     /// Error reading a HUGR model payload.
-    #[error(transparent)]
+    #[error("Model text parsing error")]
     ModelTextRead {
         /// The source error.
         #[from]
@@ -826,6 +851,6 @@ pub(crate) mod test {
 
         let err_msg = with_gen.to_string();
         assert!(err_msg.contains("Extension 'test' version mismatch"));
-        assert!(err_msg.contains(generator_name.to_string().as_str()));
+        assert!(err_msg.contains("TestGenerator-v1.2.3"));
     }
 }

hugr-core/src/envelope/package_json.rs

@@ -77,15 +77,16 @@ pub(super) fn to_json_writer<'h>(
 /// Error raised while loading a package.
 #[derive(Debug, Display, Error, From)]
 #[non_exhaustive]
+#[display("Error reading or writing a package in JSON format.")]
 pub enum PackageEncodingError {
     /// Error raised while parsing the package json.
-    JsonEncoding(serde_json::Error),
+    JsonEncoding(#[from] serde_json::Error),
     /// Error raised while reading from a file.
-    IOError(io::Error),
+    IOError(#[from] io::Error),
     /// Could not resolve the extension needed to encode the hugr.
-    ExtensionResolution(WithGenerator<ExtensionResolutionError>),
+    ExtensionResolution(#[from] WithGenerator<ExtensionResolutionError>),
     /// Error raised while checking for breaking extension version mismatch.
-    ExtensionVersion(WithGenerator<ExtensionBreakingError>),
+    ExtensionVersion(#[from] WithGenerator<ExtensionBreakingError>),
 }
 
 /// A private package structure implementing the serde traits.

hugr-core/src/extension.rs

@@ -706,6 +706,7 @@ pub enum ExtensionRegistryError {
 /// An error that can occur while loading an extension registry.
 #[derive(Debug, Error)]
 #[non_exhaustive]
+#[error("Extension registry load error")]
 pub enum ExtensionRegistryLoadError {
     /// Deserialization error.
     #[error(transparent)]