valguard-sdk 0.3.1__tar.gz

valguard_sdk-0.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ValGuard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

valguard_sdk-0.3.1/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: valguard-sdk
+Version: 0.3.1
+Summary: OpenAI-compatible client helpers for the ValGuard integrity layer
+Author: ValGuard
+License: MIT
+Project-URL: Homepage, https://valguard.ai
+Project-URL: Documentation, https://valguard.ai/docs/quickstart
+Project-URL: Repository, https://github.com/valguard-ai/sdk-python
+Project-URL: Source, https://github.com/valguard-ai/sdk-python
+Keywords: llm,openai,validation,guardrails,valguard
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Dynamic: license-file
+
+# valguard-sdk (Python)
+
+Thin Python helpers for the ValGuard OpenAI-compatible integrity layer.
+
+**Package name: `valguard-sdk`.** `pip install valguard` installs an unrelated third-party project. Import this SDK as `valguard`.
+
+Public GitHub: [github.com/valguard-ai/sdk-python](https://github.com/valguard-ai/sdk-python).
+
+Set `VG_PROXY` to your layer URL — see [valguard.ai/docs/quickstart](https://valguard.ai/docs/quickstart).
+
+## Install
+
+```bash
+pip install valguard-sdk
+# or, from this repo: pip install "git+https://github.com/valguard-ai/sdk-python.git"
+pip install openai   # optional, for OpenAI SDK bridge
+```
+
+## Environment
+
+```bash
+export VG_PROXY="https://api.valguard.ai"   # your layer base URL
+export VG_API_KEY="vg_live_..."
+export VG_AGENT="invoice_extraction_agent"
+export VG_PROVIDER_KEY="sk-..."             # optional BYOK upstream key
+```
+
+## with_agent and with_playbook
+
+`with_agent` sets `X-VG-Agent`. `with_playbook` sets `X-VG-Flow`. Pass `provider_key` (or `VG_PROVIDER_KEY` via `from_env`) so `openai_client_kwargs()` includes `X-Provider-Key`.
+
+```python
+vg = ValGuardClient.from_env().with_playbook("invoice-processing")
+```
+
+## OpenAI SDK (recommended)
+
+```python
+from openai import OpenAI
+from valguard import ValGuardClient
+
+vg = ValGuardClient.from_env()
+client = OpenAI(**vg.openai_client_kwargs())
+
+raw = client.with_raw_response.chat.completions.create(
+    model="openai/gpt-4o-mini",
+    messages=[{"role": "user", "content": "Extract invoice JSON"}],
+)
+
+print(vg.parse_response_headers(dict(raw.http_response.headers)))
+print(raw.parse())
+```
+
+## Stdlib-only HTTP
+
+```python
+from valguard import ValGuardClient
+
+vg = ValGuardClient(
+    api_key="vg_live_...",
+    base_url="https://api.valguard.ai",
+    agent_slug="default",
+    provider_key="sk-...",
+)
+
+result = vg.chat_completions(
+    model="openai/gpt-4o-mini",
+    messages=[{"role": "user", "content": "hi"}],
+)
+print(result.validation)
+print(result.data)
+```
+
+## RAG sources
+
+```python
+vg = ValGuardClient.from_env().with_rag_sources(
+    [{"id": "doc-1", "text": "Acme revenue was $4.2M in Q3."}]
+)
+```
+
+## Errors
+
+```python
+from valguard import ValGuardClient, ValGuardError
+
+try:
+    vg.chat_completions(model="openai/gpt-4o-mini", messages=[])
+except ValGuardError as err:
+    print(err.info.type)  # validation_block, input_validation, rate_limit_exceeded, ...
+```
+
+Soft-fail agents return HTTP 200 with `valid: false` — inspect `result.error.soft_fail` instead of exceptions.
+
+## API surface
+
+| Symbol | Purpose |
+|--------|---------|
+| `ValGuardClient` | Main client + `from_env()` |
+| `openai_client_kwargs()` | Legacy functional helper |
+| `parse_validation_headers()` | Read `X-VG-*` headers, including repair, cache, trace, and approval |
+| `verify_proof()` / `verify_evidence()` | Offline HMAC check of a Proof download (`valguard-evidence/1`) |
+| `parse_valguard_error()` | Parse error / soft-fail JSON |
+| `ValGuardError` | Raised on non-2xx responses |
+
+`with_approval_mode("async")` sends `X-VG-Approval-Mode`. `with_idempotency_key` sends `X-VG-Idempotency-Key`. `with_trace` sends `traceparent`, `X-VG-Parent-Span-Id`, and `X-VG-Agent-Id`. Response repair is reported with `X-VG-Healed`, `X-VG-Healed-Rules`, `X-VG-Healed-Event-Count`, and `X-VG-Healed-Trace`. Presets are agent settings.

valguard_sdk-0.3.1/README.md

@@ -0,0 +1,106 @@
+# valguard-sdk (Python)
+
+Thin Python helpers for the ValGuard OpenAI-compatible integrity layer.
+
+**Package name: `valguard-sdk`.** `pip install valguard` installs an unrelated third-party project. Import this SDK as `valguard`.
+
+Public GitHub: [github.com/valguard-ai/sdk-python](https://github.com/valguard-ai/sdk-python).
+
+Set `VG_PROXY` to your layer URL — see [valguard.ai/docs/quickstart](https://valguard.ai/docs/quickstart).
+
+## Install
+
+```bash
+pip install valguard-sdk
+# or, from this repo: pip install "git+https://github.com/valguard-ai/sdk-python.git"
+pip install openai   # optional, for OpenAI SDK bridge
+```
+
+## Environment
+
+```bash
+export VG_PROXY="https://api.valguard.ai"   # your layer base URL
+export VG_API_KEY="vg_live_..."
+export VG_AGENT="invoice_extraction_agent"
+export VG_PROVIDER_KEY="sk-..."             # optional BYOK upstream key
+```
+
+## with_agent and with_playbook
+
+`with_agent` sets `X-VG-Agent`. `with_playbook` sets `X-VG-Flow`. Pass `provider_key` (or `VG_PROVIDER_KEY` via `from_env`) so `openai_client_kwargs()` includes `X-Provider-Key`.
+
+```python
+vg = ValGuardClient.from_env().with_playbook("invoice-processing")
+```
+
+## OpenAI SDK (recommended)
+
+```python
+from openai import OpenAI
+from valguard import ValGuardClient
+
+vg = ValGuardClient.from_env()
+client = OpenAI(**vg.openai_client_kwargs())
+
+raw = client.with_raw_response.chat.completions.create(
+    model="openai/gpt-4o-mini",
+    messages=[{"role": "user", "content": "Extract invoice JSON"}],
+)
+
+print(vg.parse_response_headers(dict(raw.http_response.headers)))
+print(raw.parse())
+```
+
+## Stdlib-only HTTP
+
+```python
+from valguard import ValGuardClient
+
+vg = ValGuardClient(
+    api_key="vg_live_...",
+    base_url="https://api.valguard.ai",
+    agent_slug="default",
+    provider_key="sk-...",
+)
+
+result = vg.chat_completions(
+    model="openai/gpt-4o-mini",
+    messages=[{"role": "user", "content": "hi"}],
+)
+print(result.validation)
+print(result.data)
+```
+
+## RAG sources
+
+```python
+vg = ValGuardClient.from_env().with_rag_sources(
+    [{"id": "doc-1", "text": "Acme revenue was $4.2M in Q3."}]
+)
+```
+
+## Errors
+
+```python
+from valguard import ValGuardClient, ValGuardError
+
+try:
+    vg.chat_completions(model="openai/gpt-4o-mini", messages=[])
+except ValGuardError as err:
+    print(err.info.type)  # validation_block, input_validation, rate_limit_exceeded, ...
+```
+
+Soft-fail agents return HTTP 200 with `valid: false` — inspect `result.error.soft_fail` instead of exceptions.
+
+## API surface
+
+| Symbol | Purpose |
+|--------|---------|
+| `ValGuardClient` | Main client + `from_env()` |
+| `openai_client_kwargs()` | Legacy functional helper |
+| `parse_validation_headers()` | Read `X-VG-*` headers, including repair, cache, trace, and approval |
+| `verify_proof()` / `verify_evidence()` | Offline HMAC check of a Proof download (`valguard-evidence/1`) |
+| `parse_valguard_error()` | Parse error / soft-fail JSON |
+| `ValGuardError` | Raised on non-2xx responses |
+
+`with_approval_mode("async")` sends `X-VG-Approval-Mode`. `with_idempotency_key` sends `X-VG-Idempotency-Key`. `with_trace` sends `traceparent`, `X-VG-Parent-Span-Id`, and `X-VG-Agent-Id`. Response repair is reported with `X-VG-Healed`, `X-VG-Healed-Rules`, `X-VG-Healed-Event-Count`, and `X-VG-Healed-Trace`. Presets are agent settings.

valguard_sdk-0.3.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# Distribution name. `pip install valguard` is an unrelated third-party package.
+# Install this SDK as `valguard-sdk`. The import package remains `valguard`.
+name = "valguard-sdk"
+version = "0.3.1"
+description = "OpenAI-compatible client helpers for the ValGuard integrity layer"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "ValGuard" }]
+keywords = ["llm", "openai", "validation", "guardrails", "valguard"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.optional-dependencies]
+openai = ["openai>=1.0.0"]
+
+[project.urls]
+Homepage = "https://valguard.ai"
+Documentation = "https://valguard.ai/docs/quickstart"
+Repository = "https://github.com/valguard-ai/sdk-python"
+Source = "https://github.com/valguard-ai/sdk-python"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["valguard*"]

valguard_sdk-0.3.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

valguard_sdk-0.3.1/tests/test_evidence.py

@@ -0,0 +1,28 @@
+from valguard.evidence import EVIDENCE_TYP, verify_evidence, verify_proof
+
+SECRET = "contract-test-evidence-secret"
+KEY_ID = "org:bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb:v1"
+PAYLOAD = (
+    '{"typ":"valguard-evidence/1","request_id":"aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",'
+    '"org_id":"bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb","checked_at":"2026-03-15T08:30:00Z",'
+    '"engine_version":"valguard-engine/1","policy_snapshot_hash":"policy-1",'
+    '"request_digest":"sha256:758d61f26a44448384e5c4468a0dcb7a2abe456067b0f7b505bc28b9411fe931",'
+    '"response_digest":"sha256:9795c5ff8937f23526ccb207a5684c1fc94a7854e19c021b39d944e51f5baef2",'
+    '"verdicts":[]}'
+)
+SIGNATURE = "sha256=35b87328b2f2c94b34658646f15e993fe900e1a79fe75558b4b6140d55b3003a"
+
+
+def test_verify_evidence_contract_vector() -> None:
+    assert EVIDENCE_TYP == "valguard-evidence/1"
+    assert verify_evidence(KEY_ID, PAYLOAD, SIGNATURE, SECRET) is True
+    assert verify_evidence(KEY_ID, PAYLOAD, SIGNATURE + "x", SECRET) is False
+    assert verify_evidence(KEY_ID, PAYLOAD[:-1] + "x", SIGNATURE, SECRET) is False
+    assert verify_evidence(KEY_ID, PAYLOAD, SIGNATURE, "") is False
+
+
+def test_verify_proof_json_and_mapping() -> None:
+    record = {"key_id": KEY_ID, "payload": PAYLOAD, "signature": SIGNATURE}
+    assert verify_proof(record, SECRET) is True
+    assert verify_proof('{"key_id":"x"}', SECRET) is False
+    assert verify_proof("{", SECRET) is False

valguard_sdk-0.3.1/tests/test_headers.py

@@ -0,0 +1,134 @@
+from valguard.errors import parse_valguard_error
+from valguard.headers import parse_validation_headers
+
+
+def test_parse_validation_headers() -> None:
+    parsed = parse_validation_headers(
+        {
+            "X-VG-Validation-Status": "shadow",
+            "X-VG-Shadow-Mode": "true",
+            "X-VG-Latency-ms": "12",
+            "X-VG-Request-Id": "abc-123",
+        }
+    )
+    assert parsed.validation_status == "shadow"
+    assert parsed.shadow_mode is True
+    assert parsed.latency_ms == 12
+    assert parsed.request_id == "abc-123"
+
+
+def test_parse_orchestration_headers() -> None:
+    parsed = parse_validation_headers(
+        {
+            "X-VG-Target-Type": "playbook",
+            "X-VG-Orchestration-Path": "a,b,c",
+            "X-VG-Orchestration-Validations-Used": "5",
+            "X-VG-Requests-Remaining": "unlimited",
+            "X-VG-Idempotency-Replayed": "true",
+        }
+    )
+    assert parsed.target_type == "playbook"
+    assert parsed.orchestration_path == "a,b,c"
+    assert parsed.orchestration_validations_used == 5
+    assert parsed.orchestration_executions_remaining == "unlimited"
+    assert parsed.idempotency_replayed is True
+
+
+def test_parse_repair_trace_and_run_headers() -> None:
+    parsed = parse_validation_headers(
+        {
+            "X-VG-Validation-Status": "stream_passthrough",
+            "X-VG-Healed": "true",
+            "X-VG-Healed-Rules": "tier1:trim_whitespace,tier2:enum_normalize",
+            "X-VG-Healed-Event-Count": "2",
+            "X-VG-Healed-Trace": "tier1:trim_whitespace@_,tier2:enum_normalize@status",
+            "X-VG-Cache": "cache_hit",
+            "X-Trace-Id": "trace-1",
+            "X-VG-Span-Id": "span-1",
+            "X-VG-Parent-Span-Id": "parent-1",
+            "X-VG-Agent-Id": "billing-agent",
+            "X-VG-Run-Id": "run-1",
+            "X-VG-Run-Status": "waiting_approval",
+            "X-VG-Approval-Id": "appr-1",
+            "X-VG-License-Status": "valid",
+            "X-VG-License-Mode": "enforce",
+        }
+    )
+    assert parsed.validation_status == "stream_passthrough"
+    assert parsed.healed is True
+    assert parsed.healed_rules == ("tier1:trim_whitespace", "tier2:enum_normalize")
+    assert parsed.healed_event_count == 2
+    assert parsed.healed_trace == ("tier1:trim_whitespace@_", "tier2:enum_normalize@status")
+    assert parsed.cache_status == "cache_hit"
+    assert parsed.trace_id == "trace-1"
+    assert parsed.span_id == "span-1"
+    assert parsed.parent_span_id == "parent-1"
+    assert parsed.agent_id == "billing-agent"
+    assert parsed.run_id == "run-1"
+    assert parsed.run_status == "waiting_approval"
+    assert parsed.approval_id == "appr-1"
+    assert parsed.license_status == "valid"
+    assert parsed.license_mode == "enforce"
+
+
+def test_unknown_validation_status_is_dropped() -> None:
+    parsed = parse_validation_headers({"X-VG-Validation-Status": "reasked_ok"})
+    assert parsed.validation_status is None
+
+
+def test_request_headers_for_approval_and_trace() -> None:
+    from valguard.client import ValGuardClient
+
+    client = ValGuardClient(
+        api_key="vg_test",
+        base_url="https://api.example.com",
+        agent_slug="",
+        flow_slug="invoice-processing",
+        provider_key="sk-up",
+    ).with_idempotency_key("idem-1").with_approval_mode("async").with_trace(
+        traceparent="00-abc-def-01",
+        parent_span_id="parent",
+        agent_id="billing-agent",
+    )
+    headers = client.build_headers()
+    assert headers["X-VG-Flow"] == "invoice-processing"
+    assert "X-VG-Agent" not in headers
+    assert headers["X-VG-Idempotency-Key"] == "idem-1"
+    assert headers["X-VG-Approval-Mode"] == "async"
+    assert headers["traceparent"] == "00-abc-def-01"
+    assert headers["X-VG-Parent-Span-Id"] == "parent"
+    assert headers["X-VG-Agent-Id"] == "billing-agent"
+    assert headers["X-Provider-Key"] == "sk-up"
+    openai = client.openai_client_kwargs()
+    assert "Authorization" not in openai["default_headers"]
+    assert openai["default_headers"]["X-VG-Approval-Mode"] == "async"
+    assert openai["default_headers"]["X-Provider-Key"] == "sk-up"
+
+
+def test_parse_soft_fail() -> None:
+    info = parse_valguard_error(
+        200,
+        {"valid": False, "validation": {"status": "block", "failures": []}},
+    )
+    assert info is not None
+    assert info.soft_fail is True
+
+
+def test_parse_validation_block() -> None:
+    info = parse_valguard_error(
+        403,
+        {"error": {"type": "validation_block", "reason": "required_fields", "message": "blocked"}},
+    )
+    assert info is not None
+    assert info.type == "validation_block"
+
+
+if __name__ == "__main__":
+    test_parse_validation_headers()
+    test_parse_orchestration_headers()
+    test_parse_repair_trace_and_run_headers()
+    test_unknown_validation_status_is_dropped()
+    test_request_headers_for_approval_and_trace()
+    test_parse_soft_fail()
+    test_parse_validation_block()
+    print("sdk-python tests: ok")

valguard_sdk-0.3.1/tests/test_internal.py

@@ -0,0 +1,26 @@
+from valguard.client import ValGuardClient
+
+
+def test_build_internal_test_headers_api_key() -> None:
+    client = ValGuardClient(api_key="vg_test", base_url="https://api.example.com")
+    headers = client._build_internal_test_headers()
+    assert headers["Authorization"] == "Bearer vg_test"
+
+
+def test_build_internal_test_headers_secret() -> None:
+    client = ValGuardClient(
+        api_key="",
+        base_url="https://api.example.com",
+        internal_secret="secret",
+        project_id="proj-1",
+    )
+    headers = client._build_internal_test_headers()
+    assert headers["X-VG-Internal-Secret"] == "secret"
+    assert headers["X-VG-Project-Id"] == "proj-1"
+    assert "Authorization" not in headers
+
+
+if __name__ == "__main__":
+    test_build_internal_test_headers_api_key()
+    test_build_internal_test_headers_secret()
+    print("test_internal: ok")

valguard_sdk-0.3.1/tests/test_playbook.py

@@ -0,0 +1,33 @@
+from valguard.client import ValGuardClient
+
+
+def test_with_playbook_headers() -> None:
+    client = ValGuardClient(
+        api_key="vg_test",
+        base_url="https://api.example.com",
+        agent_slug="",
+        flow_slug="invoice-processing",
+    )
+    headers = client.build_headers()
+    assert headers["X-VG-Flow"] == "invoice-processing"
+    assert "X-VG-Agent" not in headers
+
+
+def test_mutually_exclusive_headers() -> None:
+    client = ValGuardClient(
+        api_key="vg_test",
+        base_url="https://api.example.com",
+        agent_slug="a",
+        flow_slug="f",
+    )
+    try:
+        client.build_headers()
+        raise AssertionError("expected ValueError")
+    except ValueError as e:
+        assert "mutually_exclusive_headers" in str(e)
+
+
+if __name__ == "__main__":
+    test_with_playbook_headers()
+    test_mutually_exclusive_headers()
+    print("test_playbook: ok")

valguard_sdk-0.3.1/tests/test_webhook.py

@@ -0,0 +1,25 @@
+from valguard.webhook import (
+    WEBHOOK_SIGNATURE_HEADER,
+    sign_webhook_payload,
+    verify_webhook_signature,
+)
+
+CONTRACT_SECRET = "contract-test-webhook-secret"
+CONTRACT_BODY = b'{"event":"validation.block","request_id":"abc"}'
+CONTRACT_SIG = sign_webhook_payload(CONTRACT_BODY, CONTRACT_SECRET, 1700000000)
+
+
+def test_webhook_signature_contract() -> None:
+    assert WEBHOOK_SIGNATURE_HEADER == "X-VG-Signature"
+    assert CONTRACT_SIG.startswith("t=1700000000,v1=")
+    assert verify_webhook_signature(CONTRACT_BODY, CONTRACT_SIG, CONTRACT_SECRET, max_age_seconds=None) is True
+    assert verify_webhook_signature(CONTRACT_BODY.decode(), CONTRACT_SIG, CONTRACT_SECRET, max_age_seconds=None) is True
+    assert verify_webhook_signature(CONTRACT_BODY, "sha256=bad", CONTRACT_SECRET) is False
+    assert verify_webhook_signature(CONTRACT_BODY, CONTRACT_SIG, "") is False
+    fresh = sign_webhook_payload("hello", CONTRACT_SECRET)
+    assert verify_webhook_signature("hello", fresh, CONTRACT_SECRET) is True
+
+
+if __name__ == "__main__":
+    test_webhook_signature_contract()
+    print("test_webhook: ok")

valguard_sdk-0.3.1/valguard/__init__.py

@@ -0,0 +1,52 @@
+"""ValGuard integration helpers for the OpenAI-compatible layer."""
+
+from valguard.client import ChatCompletionResult, TestValidatorsResult, ValGuardClient
+from valguard.errors import ValGuardError, ValGuardErrorInfo, parse_valguard_error
+from valguard.evidence import EVIDENCE_TYP, verify_evidence, verify_proof
+from valguard.headers import ValidationHeaders, parse_validation_headers
+from valguard.webhook import (
+    WEBHOOK_SIGNATURE_HEADER,
+    sign_webhook_payload,
+    verify_webhook_signature,
+)
+
+
+def openai_client_kwargs(
+    api_key: str,
+    base_url: str,
+    agent_slug: str,
+    provider_key: str | None = None,
+) -> dict:
+    """Backward-compatible helper — prefer ValGuardClient.openai_client_kwargs().
+
+    Pass provider_key so the OpenAI client sends X-Provider-Key (BYOK).
+    """
+    return ValGuardClient(
+        api_key=api_key,
+        base_url=base_url,
+        agent_slug=agent_slug,
+        provider_key=provider_key,
+    ).openai_client_kwargs()
+
+
+__all__ = [
+    "ChatCompletionResult",
+    "EVIDENCE_TYP",
+    "TestValidatorsResult",
+    "ValGuardClient",
+    "ValGuardError",
+    "ValGuardErrorInfo",
+    "ValidationHeaders",
+    "WEBHOOK_SIGNATURE_HEADER",
+    "openai_client_kwargs",
+    "parse_response_headers",
+    "parse_valguard_error",
+    "parse_validation_headers",
+    "sign_webhook_payload",
+    "verify_evidence",
+    "verify_proof",
+    "verify_webhook_signature",
+]
+
+# Alias for symmetry with the Node SDK
+parse_response_headers = parse_validation_headers