feat(config): add Bool type support for target arguments

Adds `Bool` to the `ArgumentType` enum for target configuration, enabling
boolean flags that can be specified without a value.

## Changes

### Core Type Support
- Add `Bool` to `ArgumentType` enum in TargetConfig.h
- Add YAML mapping "bool" -> ArgumentType::Bool in TargetConfig.cpp

### Typed Value Utilities
- Add `getTypedConfigValue()` to ServerHelper for proper JSON serialization
- Add `getArgumentType()` to look up declared types from target config
- Bool values serialize as JSON boolean literals (not strings)

### nvq++ Compiler Support
- Add `--list-bool-args` mode to cudaq-target-conf tool
- Modify nvq++ to detect Bool arguments and handle shift 1 vs shift 2
- Bool args can be specified without value (defaults to true)

### Backend Updates
- Update IonQ backend: change `debias` and `sharpen` to `type: bool`
- Simplify backend code using new typed value utilities

### Tests
- Add unit test for Bool argument YAML parsing
- Add integration test for --list-bool-args output
- Add test YAML config with Bool/String/Int arguments

## Usage

Target YAML:
```yaml
target-arguments:
  - key: debias
    type: bool
    platform-arg: debias
```

Command line:
```bash
nvq++ --target ionq --ionq-debias program.cpp      # defaults to true
nvq++ --target ionq --ionq-debias true program.cpp # explicit true
nvq++ --target ionq --ionq-debias=false program.cpp # explicit false
```

Fixes #3699
Fixes #3525

Signed-off-by: andrewtkent <andrew_kent@brown.edu>

Author: AndrewTKent

include/cudaq/Support/TargetConfig.h

@@ -29,7 +29,7 @@ enum TargetFeatureFlag : unsigned {
 
 /// @brief Configuration argument type annotation
 // e.g., to support type validation.
-enum class ArgumentType { String, Int, UUID, FeatureFlag, MachineConfig };
+enum class ArgumentType { String, Int, Bool, UUID, FeatureFlag, MachineConfig };
 
 /// @brief Architecture-specific compilation settings
 // Different device architectures of a target may require customization.

lib/Support/Config/TargetConfig.cpp

@@ -267,6 +267,7 @@ void ScalarEnumerationTraits<cudaq::config::ArgumentType>::enumeration(
     IO &io, cudaq::config::ArgumentType &value) {
   io.enumCase(value, "string", cudaq::config::ArgumentType::String);
   io.enumCase(value, "integer", cudaq::config::ArgumentType::Int);
+  io.enumCase(value, "bool", cudaq::config::ArgumentType::Bool);
   io.enumCase(value, "uuid", cudaq::config::ArgumentType::UUID);
   io.enumCase(value, "option-flags", cudaq::config::ArgumentType::FeatureFlag);
   io.enumCase(value, "machine-config",

runtime/common/ServerHelper.cpp

@@ -38,6 +38,53 @@ void ServerHelper::parseConfigForCommonParams(const BackendConfig &config) {
     }
   }
 }
+
+std::optional<config::ArgumentType>
+ServerHelper::getArgumentType(const std::string &key) const {
+  for (const auto &arg : runtimeTarget.config.TargetArguments)
+    // Check both the key name and platform-arg key
+    if (arg.KeyName == key || arg.PlatformArgKey == key)
+      return arg.Type;
+  return std::nullopt;
+}
+
+nlohmann::json ServerHelper::getTypedConfigValue(const std::string &key) const {
+  auto it = backendConfig.find(key);
+  if (it == backendConfig.end())
+    return nlohmann::json(); // null
+
+  const std::string &value = it->second;
+  auto argType = getArgumentType(key);
+
+  // If no type info available, return as string
+  if (!argType.has_value())
+    return value;
+
+  switch (argType.value()) {
+  case config::ArgumentType::Bool:
+    // Handle common boolean string representations
+    if (value == "true" || value == "True" || value == "TRUE" || value == "1")
+      return true;
+    if (value == "false" || value == "False" || value == "FALSE" || value == "0")
+      return false;
+    throw std::runtime_error("Invalid boolean value for '" + key + "': '" +
+                             value + "'. Expected true/false/1/0.");
+  case config::ArgumentType::Int: {
+    try {
+      return std::stoll(value);
+    } catch (...) {
+      // If parsing fails, return as string
+      return value;
+    }
+  }
+  case config::ArgumentType::String:
+  case config::ArgumentType::UUID:
+  case config::ArgumentType::FeatureFlag:
+  case config::ArgumentType::MachineConfig:
+  default:
+    return value;
+  }
+}
 } // namespace cudaq
 
 LLVM_INSTANTIATE_REGISTRY(cudaq::ServerHelper::RegistryType)

runtime/common/ServerHelper.h

@@ -16,6 +16,7 @@
 #include "common/RecordLogParser.h"
 #include "nlohmann/json.hpp"
 #include <filesystem>
+#include <optional>
 
 namespace cudaq {
 
@@ -91,6 +92,20 @@ class ServerHelper : public registry::RegisteredType<ServerHelper> {
   /// @brief  Information about the runtime target managing this server helper.
   RuntimeTarget runtimeTarget;
 
+  /// @brief Get the ArgumentType for a config key from target configuration.
+  /// @param key The config key to look up
+  /// @return The ArgumentType if found, std::nullopt otherwise
+  std::optional<config::ArgumentType> getArgumentType(const std::string &key) const;
+
+  /// @brief Get a config value converted to the appropriate JSON type based on
+  /// the ArgumentType declared in the target configuration.
+  /// - Bool: converts "true"/"false" strings to JSON boolean
+  /// - Int: converts numeric strings to JSON number
+  /// - String/UUID/others: keeps as JSON string
+  /// @param key The config key to retrieve
+  /// @return JSON value with appropriate type, or null if key not found
+  nlohmann::json getTypedConfigValue(const std::string &key) const;
+
 public:
   ServerHelper() = default;
   virtual ~ServerHelper() = default;

runtime/cudaq/platform/default/rest/helpers/ionq/IonQServerHelper.cpp

@@ -205,14 +205,10 @@ IonQServerHelper::createJob(std::vector<KernelExecution> &circuitCodes) {
     job["input"]["data"] = circuitCode.code;
     // Include error mitigation configuration if set in backendConfig
     if (keyExists("debias")) {
-      try {
-        bool debiasValue =
-            nlohmann::json::parse(backendConfig["debias"]).get<bool>();
-        job["error_mitigation"]["debias"] = debiasValue;
-      } catch (const nlohmann::json::exception &e) {
-        throw std::runtime_error(
-            "Invalid value for 'debias'. It should be a boolean (true/false).");
-      }
+      job["error_mitigation"]["debias"] = getTypedConfigValue("debias");
+    }
+    if (keyExists("sharpen")) {
+      job["error_mitigation"]["sharpen"] = getTypedConfigValue("sharpen");
     }
 
     jobs.push_back(job);

runtime/cudaq/platform/default/rest/helpers/ionq/ionq.yml

@@ -40,11 +40,11 @@ target-arguments:
     help-string: "Specify the noise model for simulation."
   - key: debias
     required: false
-    type: string
-    platform-arg: debias 
-    help-string: "Specify debiasing."
+    type: bool
+    platform-arg: debias
+    help-string: "Enable debiasing error mitigation."
   - key: sharpen
     required: false
-    type: string
+    type: bool
     platform-arg: sharpen
-    help-string: "Specify sharpening."
+    help-string: "Enable sharpening error mitigation."

targettests/TargetConfig/Inputs/test-bool-args.yml

@@ -0,0 +1,42 @@
+# ============================================================================ #
+# Copyright (c) 2022 - 2026 NVIDIA Corporation & Affiliates.                   #
+# All rights reserved.                                                         #
+#                                                                              #
+# This source code and the accompanying materials are made available under     #
+# the terms of the Apache License 2.0 which accompanies this distribution.     #
+# ============================================================================ #
+
+# Test target configuration with Bool arguments for testing --list-bool-args
+
+name: test-bool-args
+description: "Test target for Bool argument type validation."
+config:
+  platform-qpu: remote_rest
+  codegen-emission: qir-base
+  library-mode: false
+
+target-arguments:
+  - key: enable-opt
+    required: false
+    type: bool
+    platform-arg: enable_opt
+    help-string: "Enable optimization (Bool flag, no value needed)."
+  - key: debug
+    required: false
+    type: bool
+    help-string: "Enable debug mode (Bool flag)."
+  - key: verbose
+    required: false
+    type: bool
+    platform-arg: verbose
+    help-string: "Enable verbose output (Bool flag)."
+  - key: machine
+    required: false
+    type: string
+    platform-arg: qpu
+    help-string: "Specify QPU (string argument, should NOT appear in bool list)."
+  - key: shots
+    required: false
+    type: integer
+    platform-arg: shots
+    help-string: "Number of shots (integer argument, should NOT appear in bool list)."

targettests/TargetConfig/check_bool_args.config

@@ -0,0 +1,21 @@
+# ============================================================================ #
+# Copyright (c) 2022 - 2026 NVIDIA Corporation & Affiliates.                   #
+# All rights reserved.                                                         #
+#                                                                              #
+# This source code and the accompanying materials are made available under     #
+# the terms of the Apache License 2.0 which accompanies this distribution.     #
+# ============================================================================ #
+
+# Validate that cudaq-target-conf --list-bool-args correctly identifies Bool arguments
+# and excludes non-Bool arguments (string, integer, etc.)
+
+# RUN: cudaq-target-conf --list-bool-args %cudaq_src_dir/targettests/TargetConfig/Inputs/test-bool-args.yml | FileCheck %s
+
+# Bool arguments should be listed
+# CHECK-DAG: enable-opt
+# CHECK-DAG: debug
+# CHECK-DAG: verbose
+
+# Non-Bool arguments should NOT be listed
+# CHECK-NOT: machine
+# CHECK-NOT: shots

test/NVQPP/bool_target_args.cpp

@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2022 - 2026 NVIDIA Corporation & Affiliates.                  *
+ * All rights reserved.                                                        *
+ *                                                                             *
+ * This source code and the accompanying materials are made available under    *
+ * the terms of the Apache License 2.0 which accompanies this distribution.    *
+ ******************************************************************************/
+
+// Test that Bool-type target arguments are correctly passed to the backend
+// configuration. Bool args can be specified without a value (implicit true).
+
+// Test 1: Implicit true (--ionq-debias without value means true)
+// RUN: nvq++ -v --target ionq --ionq-debias %s -o %t |& FileCheck --check-prefix=IMPLICIT %s
+
+// Test 2: Explicit true
+// RUN: nvq++ -v --target ionq --ionq-debias true %s -o %t |& FileCheck --check-prefix=EXPLICIT %s
+
+// Test 3: Explicit false using = syntax
+// RUN: nvq++ -v --target ionq --ionq-debias=false %s -o %t |& FileCheck --check-prefix=FALSE %s
+
+// IMPLICIT: -DNVQPP_TARGET_BACKEND_CONFIG
+// IMPLICIT-SAME: debias;true
+
+// EXPLICIT: -DNVQPP_TARGET_BACKEND_CONFIG
+// EXPLICIT-SAME: debias;true
+
+// FALSE: -DNVQPP_TARGET_BACKEND_CONFIG
+// FALSE-SAME: debias;false
+
+#include <cudaq.h>
+
+struct test_kernel {
+  void operator()() __qpu__ {
+    cudaq::qubit q;
+    h(q);
+  }
+};
+
+int main() {
+  return 0;
+}

tools/cudaq-target-conf/cudaq-target-conf.cpp

@@ -51,6 +51,11 @@ static cl::opt<bool> skipGpuCheck(
     cl::desc("Skip NVIDIA check on target configuration that requires GPUs."),
     cl::init(false));
 
+static cl::opt<bool> listBoolArgs(
+    "list-bool-args",
+    cl::desc("List argument keys that are Bool type (no value required)."),
+    cl::init(false));
+
 static constexpr const char BOLD[] = "\033[1m";
 static constexpr const char RED[] = "\033[91m";
 static constexpr const char CLEAR[] = "\033[0m";
@@ -108,6 +113,15 @@ int main(int argc, char **argv) {
   llvm::yaml::Input Input(*(fileOrErr.get()));
   Input >> config;
 
+  // If --list-bool-args is specified, just output Bool argument keys and exit
+  if (listBoolArgs) {
+    for (const auto &arg : config.TargetArguments) {
+      if (arg.Type == cudaq::config::ArgumentType::Bool)
+        llvm::outs() << arg.KeyName << "\n";
+    }
+    return 0;
+  }
+
   // Verify GPU requirement
   if (!skipGpuCheck && config.GpuRequired && countGPUs() <= 0) {
     llvm::errs() << "Target '" << config.Name