refactor: Move backend-specific args to --backend_args

Refactors the CLI arguments to move backend-specific options under the
`--backend-args` flag.

- Removes `--target-header` and `--target-skip-ssl-verify` from the CLI.
- Updates the `OpenAIHTTPBackend` to parse `headers` and `verify` from the `backend_args` dictionary.
- Renames `verify_ssl` to the protocol-neutral term `verify`.
- Updates documentation and tests to reflect the new argument structure.

Author: kdelee

docs/guides/cli.md

@@ -19,9 +19,8 @@ These options configure how `guidellm` connects to the system under test.
 | Option | Description |
 | --- | --- |
 | `--target <URL>` | **Required.** The endpoint of the target system, e.g., `http://localhost:8080`. Can also be set with the `GUIDELLM__OPENAI__BASE_URL` environment variable. |
-| `--target-header <HEADER>` | A header to send with requests to the target. Can be specified multiple times. Example: `--target-header "Authorization: Bearer my-secret-token"`. |
-| `--target-skip-ssl-verify` | A flag to disable SSL certificate verification when connecting to the target. |
 | `--backend-type <TYPE>` | The type of backend to use. Defaults to `openai_http`. |
+| `--backend-args <JSON>` | A JSON string for backend-specific arguments. For example: `--backend-args '{"headers": {"Authorization": "Bearer my-token"}, "verify": false}'` to pass custom headers and disable certificate verification. |
 | `--model <NAME>` | The ID of the model to benchmark within the backend. |
 
 ### Data and Request Configuration

docs/guides/configuration.md

@@ -31,7 +31,7 @@ You can configure the connection to the target system using environment variable
 | `GUIDELLM__OPENAI__HEADERS` | A JSON string representing a dictionary of headers to send to the target. These headers will override any default headers. | `export GUIDELLM__OPENAI__HEADERS='{"Authorization": "Bearer my-token"}'` |
 | `GUIDELLM__OPENAI__ORGANIZATION` | The OpenAI organization to use for requests. | `export GUIDELLM__OPENAI__ORGANIZATION="org-12345"` |
 | `GUIDELLM__OPENAI__PROJECT` | The OpenAI project to use for requests. | `export GUIDELLM__OPENAI__PROJECT="proj-67890"` |
-| `GUIDELLM__OPENAI__VERIFY_SSL` | Set to `false` or `0` to disable SSL certificate verification. | `export GUIDELLM__OPENAI__VERIFY_SSL=false` |
+| `GUIDELLM__OPENAI__VERIFY` | Set to `false` or `0` to disable certificate verification. | `export GUIDELLM__OPENAI__VERIFY=false` |
 | `GUIDELLM__OPENAI__MAX_OUTPUT_TOKENS` | The default maximum number of tokens to request for completions. | `export GUIDELLM__OPENAI__MAX_OUTPUT_TOKENS=2048` |
 
 ### General HTTP Settings
@@ -54,5 +54,5 @@ You can also place these variables in a `.env` file in your project's root direc
 GUIDELLM__OPENAI__BASE_URL="http://localhost:8080"
 GUIDELLM__OPENAI__API_KEY="your-api-key"
 GUIDELLM__OPENAI__HEADERS='{"Authorization": "Bearer my-token"}'
-GUIDELLM__OPENAI__VERIFY_SSL=false
+GUIDELLM__OPENAI__VERIFY=false
 ```

src/guidellm/__main__.py

@@ -85,18 +85,6 @@ def benchmark():
         "dict with **kwargs."
     ),
 )
-@click.option(
-    "--target-header",
-    "target_headers",
-    multiple=True,
-    help="A header to send to the target, e.g., --target-header 'Authorization: Bearer <token>'. Can be specified multiple times.",
-)
-@click.option(
-    "--target-skip-ssl-verify",
-    is_flag=True,
-    default=False,
-    help="Skip SSL certificate verification when sending requests to the target.",
-)
 @click.option(
     "--model",
     default=GenerativeTextScenario.get_default("model"),
@@ -261,8 +249,6 @@ def run(
     target,
     backend_type,
     backend_args,
-    target_headers,
-    target_skip_ssl_verify,
     model,
     processor,
     processor_args,
@@ -285,21 +271,6 @@ def run(
 ):
     click_ctx = click.get_current_context()
 
-    if target_headers:
-        headers = {}
-        for header in target_headers:
-            if ":" not in header:
-                raise click.BadParameter(
-                    f"Invalid header format: {header}. Expected 'Key: Value'.",
-                    ctx=click_ctx,
-                    param_hint="--target-header",
-                )
-            key, value = header.split(":", 1)
-            headers[key.strip()] = value.strip()
-        settings.openai.headers = headers
-    if target_skip_ssl_verify:
-        settings.openai.verify_ssl = False
-
     overrides = cli_tools.set_if_not_default(
         click_ctx,
         target=target,

src/guidellm/backend/openai.py

@@ -94,6 +94,7 @@ def __init__(
         extra_query: Optional[dict] = None,
         extra_body: Optional[dict] = None,
         remove_from_body: Optional[list[str]] = None,
+        **kwargs,
     ):
         super().__init__(type_="openai_http")
         self._target = target or settings.openai.base_url
@@ -127,8 +128,8 @@ def __init__(
         if self.project:
             default_headers["OpenAI-Project"] = self.project
 
-        # User-provided headers from CLI override defaults
-        user_headers = settings.openai.headers or {}
+        # User-provided headers from kwargs or settings override defaults
+        user_headers = kwargs.pop("headers", settings.openai.headers or {})
         default_headers.update(user_headers)
         self.headers = default_headers
 
@@ -139,7 +140,7 @@ def __init__(
             if follow_redirects is not None
             else settings.request_follow_redirects
         )
-        self.verify_ssl = settings.openai.verify_ssl
+        self.verify = kwargs.pop("verify", settings.openai.verify)
         self.max_output_tokens = (
             max_output_tokens
             if max_output_tokens is not None
@@ -397,7 +398,7 @@ def _get_async_client(self) -> httpx.AsyncClient:
                 http2=self.http2,
                 timeout=self.timeout,
                 follow_redirects=self.follow_redirects,
-                verify=self.verify_ssl,
+                verify=self.verify,
             )
             self._async_client = client
         else:

src/guidellm/config.py

@@ -86,7 +86,7 @@ class OpenAISettings(BaseModel):
     project: Optional[str] = None
     base_url: str = "http://localhost:8000"
     max_output_tokens: int = 16384
-    verify_ssl: bool = True
+    verify: bool = True
 
 
 class Settings(BaseSettings):

tests/unit/backend/test_openai_backend_custom_configs.py

@@ -7,16 +7,13 @@
 @pytest.mark.smoke
 def test_openai_http_backend_default_initialization():
     backend = OpenAIHTTPBackend()
-    assert backend.verify_ssl is True
+    assert backend.verify is True
 
 
 @pytest.mark.smoke
 def test_openai_http_backend_custom_ssl_verification():
-    settings.openai.verify_ssl = False
-    backend = OpenAIHTTPBackend()
-    assert backend.verify_ssl is False
-    # Reset the setting
-    settings.openai.verify_ssl = True
+    backend = OpenAIHTTPBackend(verify=False)
+    assert backend.verify is False
 
 
 @pytest.mark.smoke
@@ -30,10 +27,9 @@ def test_openai_http_backend_custom_headers_override():
         "Authorization": openshift_token,
         "Custom-Header": "Custom-Value",
     }
-    settings.openai.headers = override_headers
 
     # Initialize the backend
-    backend = OpenAIHTTPBackend()
+    backend = OpenAIHTTPBackend(headers=override_headers)
 
     # Check that the override headers are used
     assert backend.headers["Authorization"] == openshift_token
@@ -43,3 +39,26 @@ def test_openai_http_backend_custom_headers_override():
     # Reset the settings
     settings.openai.api_key = None
     settings.openai.headers = None
+
+
+@pytest.mark.smoke
+def test_openai_http_backend_kwarg_headers_override_settings():
+    # Set headers via settings (simulating environment variables)
+    settings.openai.headers = {"Authorization": "Bearer settings-token"}
+
+    # Set different headers via kwargs (simulating --backend-args)
+    override_headers = {
+        "Authorization": "Bearer kwargs-token",
+        "Custom-Header": "Custom-Value",
+    }
+
+    # Initialize the backend with kwargs
+    backend = OpenAIHTTPBackend(headers=override_headers)
+
+    # Check that the kwargs headers took precedence
+    assert backend.headers["Authorization"] == "Bearer kwargs-token"
+    assert backend.headers["Custom-Header"] == "Custom-Value"
+    assert len(backend.headers) == 2
+
+    # Reset the settings
+    settings.openai.headers = None

tests/unit/test_config.py

@@ -143,12 +143,12 @@ def test_settings_with_env_variables(mocker):
             "GUIDELLM__OPENAI__API_KEY": "env_api_key",
             "GUIDELLM__TABLE_BORDER_CHAR": "*",
             "GUIDELLM__OPENAI__HEADERS": '{"Authorization": "Bearer env-token"}',
-            "GUIDELLM__OPENAI__VERIFY_SSL": "false",
+            "GUIDELLM__OPENAI__VERIFY": "false",
         },
     )
     settings = Settings()
     assert settings.dataset.preferred_data_columns == ["custom_column"]
     assert settings.openai.api_key == "env_api_key"
     assert settings.table_border_char == "*"
     assert settings.openai.headers == {"Authorization": "Bearer env-token"}
-    assert settings.openai.verify_ssl is False
+    assert settings.openai.verify is False

tests/unit/test_main.py

@@ -2,44 +2,19 @@
 from click.testing import CliRunner
 
 from guidellm.__main__ import cli
+from guidellm.config import settings
 
 
 @pytest.mark.smoke
-def test_benchmark_run_invalid_header_format():
+def test_benchmark_run_with_backend_args():
     runner = CliRunner()
     result = runner.invoke(
         cli,
         [
             "benchmark",
             "run",
-            "--target-header",
-            "invalid-header",
-            "--target",
-            "http://localhost:8000",
-            "--data",
-            "prompt_tokens=1,output_tokens=1",
-            "--rate-type",
-            "constant",
-            "--rate",
-            "1",
-            "--max-requests",
-            "1",
-        ],
-    )
-    assert result.exit_code != 0
-    assert "Invalid header format" in result.output
-
-
-@pytest.mark.smoke
-def test_benchmark_run_valid_header_format():
-    runner = CliRunner()
-    result = runner.invoke(
-        cli,
-        [
-            "benchmark",
-            "run",
-            "--target-header",
-            "Authorization: Bearer my-token",
+            "--backend-args",
+            '{"headers": {"Authorization": "Bearer my-token"}, "verify": false}',
             "--target",
             "http://localhost:8000",
             "--data",
@@ -54,4 +29,5 @@ def test_benchmark_run_valid_header_format():
     )
     # This will fail because it can't connect to the server,
     # but it will pass the header parsing, which is what we want to test.
+    assert result.exit_code != 0
     assert "Invalid header format" not in result.output