drex-policy 0.1.0__tar.gz

drex_policy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nace.AI
+
+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.

drex_policy-0.1.0/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: drex-policy
+Version: 0.1.0
+Summary: Guardrails validator that checks text, or text with images, against a Drex noul or score question.
+Author-email: "Nace.AI" <alish@nace.ai>
+License-Expression: MIT
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: guardrails-ai>=0.4.0
+Requires-Dist: nace-sdk>=0.6.2
+Provides-Extra: dev
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# drex-policy
+
+A [Guardrails](https://github.com/guardrails-ai/guardrails) validator that asks Drex, Nace.AI's decision model, one question about a string.
+
+| Developed by | Nace.AI |
+| --- | --- |
+| Date of development | Oct 29, 2026 |
+| Validator type | Moderation, policy |
+| License | MIT |
+| Input/Output | Input, Output |
+
+## What it checks
+
+`DrexPolicy` asks [Drex](https://console.nace.ai/docs) one question about a string and fails when the answer crosses a threshold you set. Use it for checks such as PII present, off-topic, toxicity level, jailbreak attempt, or competitor mention.
+
+The question is a `nace_sdk.Noul` (probability of a yes answer) or a `nace_sdk.Score` (expected index over criteria you list). Drex returns the probability. You choose the threshold with `fail_at`, preferably from labeled examples from your application.
+
+- Noul: fails when P(yes) is at or above `fail_at`. With `fail_when="no"`, fails when P(yes) is below `fail_at`.
+- Score: fails when the score is at or above `fail_at`. With `fail_when="below"`, fails when the score is below `fail_at`.
+
+The Drex answer is in the result metadata on pass and on fail.
+
+## Models
+
+The default model is `drex-v2.0`. Text-only checks can use any Drex model id, which is sent unchanged. `drex-latest` is sent as `drex-latest`. It is not `drex-max`.
+
+To check images with the text, pass `model="drex-max"` and put the images in `metadata["images"]`. Each image is a URL or a data URL (PNG, JPEG, or WebP). `drex-max` accepts at most 8 images. If images are present and the model is not `drex-max`, or there are more than 8 images, the validator raises `DrexPolicyError` before it calls Drex. It does not drop the images.
+
+## Requirements
+
+* Dependencies:
+	- guardrails-ai>=0.4.0
+	- nace-sdk>=0.6.2
+
+* Access keys:
+	- `NACE_API_KEY`: a key from [console.nace.ai](https://console.nace.ai)
+	- `NACE_BASE_URL` (optional): defaults to `https://console.nace.ai`
+
+When the validator builds its own client, each HTTP attempt times out after 60 seconds, the total retry budget is 180 seconds, and requests carry `X-Nace-Client: drex-policy/0.1.0`.
+
+## Install
+
+```bash
+$ guardrails hub install hub://nace/drex_policy
+```
+
+You can also install the package from PyPI:
+
+```bash
+$ pip install drex-policy
+```
+
+With a PyPI install, import the validator from `drex_policy` instead of `guardrails.hub`:
+
+```python
+from drex_policy import DrexPolicy
+```
+
+The examples below use the hub import. The class and its arguments are the same.
+
+## Examples
+
+### Check a string
+
+```python
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Noul
+
+guard = Guard().use(
+    DrexPolicy(
+        question=Noul(instructions="Does the text contain a personal phone number or email address?"),
+        fail_at=0.5,
+        on_fail="exception",
+    )
+)
+
+guard.validate("Our office opens at 9am.")  # Validator passes
+guard.validate("Call me on +1 415 555 0100.")  # Validator fails
+```
+
+### Check text with images
+
+```python
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Score
+
+guard = Guard().use(
+    DrexPolicy(
+        question=Score(
+            instructions="How unsafe is this listing for a general audience?",
+            criteria=["safe", "borderline", "unsafe"],
+        ),
+        fail_at=1.5,
+        model="drex-max",
+        on_fail="exception",
+    )
+)
+
+guard.validate(
+    "Vintage camera, works well.",
+    metadata={"images": ["https://example.com/listing.jpg"]},
+)
+```
+
+### Check one field of structured output
+
+```python
+from pydantic import BaseModel, Field
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Noul
+
+off_topic = DrexPolicy(
+    question=Noul(instructions="Is this reply about something other than our billing product?"),
+    fail_at=0.5,
+    on_fail="exception",
+)
+
+
+class Reply(BaseModel):
+    answer: str = Field(validators=[off_topic])
+
+
+guard = Guard.for_pydantic(output_class=Reply)
+guard.parse('{"answer": "Your invoice is in Settings > Billing."}')
+```
+
+## API reference
+
+**`__init__(self, question, fail_at, fail_when=None, question_id="policy", model=None, client=None, on_fail=None)`**
+<ul>
+
+**Parameters**
+- **`question`** *(nace_sdk.Noul | nace_sdk.Score)*: The question Drex answers about the value. If `instructions` is omitted, it stays `None` and is not sent.
+- **`fail_at`** *(float)*: For a noul, a P(yes) threshold between 0 and 1. For a score, a finite expected-index threshold.
+- **`fail_when`** *(str)*: `"yes"` (default) or `"no"` for a noul. `"at_or_above"` (default) or `"below"` for a score.
+- **`question_id`** *(str)*: Key of the question in the Drex request and response. Default `"policy"`.
+- **`model`** *(str)*: Drex model id. Default `drex-v2.0`. Images need `drex-max`.
+- **`client`** *(nace_sdk.NaceClient)*: An existing client. If omitted, the validator builds one that reads `NACE_API_KEY` and `NACE_BASE_URL`.
+- **`on_fail`** *(str, Callable)*: What Guardrails does on a fail: one of `exception`, `noop`, `reask`, `fix`, `filter`, `refrain` or `fix_reask`, or a function that Guardrails calls on a fail.
+</ul>
+<br/>
+
+**`validate(self, value, metadata) -> ValidationResult`**
+<ul>
+Asks Drex the question about `value` and compares the answer with `fail_at`. Do not call it directly. `guard.parse(...)` and `guard.validate(...)` call it.
+
+If Drex cannot answer (a network error, an API error, or a response without the expected answer), the exception propagates. The validator does not turn it into a pass or a fail.
+
+**Parameters**
+- **`value`** *(str)*: The text to check.
+- **`metadata`** *(dict)*: Optional.
+
+    | Key | Type | Description | Default |
+    | --- | --- | --- | --- |
+    | `images` | list[str] | Image URLs or data URLs. Needs `model="drex-max"`; at most 8. | None |
+
+**Result metadata**
+
+| Key | Description |
+| --- | --- |
+| `drex_model` | Model id sent to Drex |
+| `drex_question_id` | The `question_id` |
+| `drex_answer` | The Drex answer, for example `{"type": "noul", "noul": 0.93}` |
+</ul>
+
+## License
+
+MIT. Copyright (c) 2026 Nace.AI. See [LICENSE](LICENSE).
+
+Scaffolding from [guardrails-ai/validator-template](https://github.com/guardrails-ai/validator-template) (Apache-2.0).

drex_policy-0.1.0/README.md

@@ -0,0 +1,173 @@
+# drex-policy
+
+A [Guardrails](https://github.com/guardrails-ai/guardrails) validator that asks Drex, Nace.AI's decision model, one question about a string.
+
+| Developed by | Nace.AI |
+| --- | --- |
+| Date of development | Oct 29, 2026 |
+| Validator type | Moderation, policy |
+| License | MIT |
+| Input/Output | Input, Output |
+
+## What it checks
+
+`DrexPolicy` asks [Drex](https://console.nace.ai/docs) one question about a string and fails when the answer crosses a threshold you set. Use it for checks such as PII present, off-topic, toxicity level, jailbreak attempt, or competitor mention.
+
+The question is a `nace_sdk.Noul` (probability of a yes answer) or a `nace_sdk.Score` (expected index over criteria you list). Drex returns the probability. You choose the threshold with `fail_at`, preferably from labeled examples from your application.
+
+- Noul: fails when P(yes) is at or above `fail_at`. With `fail_when="no"`, fails when P(yes) is below `fail_at`.
+- Score: fails when the score is at or above `fail_at`. With `fail_when="below"`, fails when the score is below `fail_at`.
+
+The Drex answer is in the result metadata on pass and on fail.
+
+## Models
+
+The default model is `drex-v2.0`. Text-only checks can use any Drex model id, which is sent unchanged. `drex-latest` is sent as `drex-latest`. It is not `drex-max`.
+
+To check images with the text, pass `model="drex-max"` and put the images in `metadata["images"]`. Each image is a URL or a data URL (PNG, JPEG, or WebP). `drex-max` accepts at most 8 images. If images are present and the model is not `drex-max`, or there are more than 8 images, the validator raises `DrexPolicyError` before it calls Drex. It does not drop the images.
+
+## Requirements
+
+* Dependencies:
+	- guardrails-ai>=0.4.0
+	- nace-sdk>=0.6.2
+
+* Access keys:
+	- `NACE_API_KEY`: a key from [console.nace.ai](https://console.nace.ai)
+	- `NACE_BASE_URL` (optional): defaults to `https://console.nace.ai`
+
+When the validator builds its own client, each HTTP attempt times out after 60 seconds, the total retry budget is 180 seconds, and requests carry `X-Nace-Client: drex-policy/0.1.0`.
+
+## Install
+
+```bash
+$ guardrails hub install hub://nace/drex_policy
+```
+
+You can also install the package from PyPI:
+
+```bash
+$ pip install drex-policy
+```
+
+With a PyPI install, import the validator from `drex_policy` instead of `guardrails.hub`:
+
+```python
+from drex_policy import DrexPolicy
+```
+
+The examples below use the hub import. The class and its arguments are the same.
+
+## Examples
+
+### Check a string
+
+```python
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Noul
+
+guard = Guard().use(
+    DrexPolicy(
+        question=Noul(instructions="Does the text contain a personal phone number or email address?"),
+        fail_at=0.5,
+        on_fail="exception",
+    )
+)
+
+guard.validate("Our office opens at 9am.")  # Validator passes
+guard.validate("Call me on +1 415 555 0100.")  # Validator fails
+```
+
+### Check text with images
+
+```python
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Score
+
+guard = Guard().use(
+    DrexPolicy(
+        question=Score(
+            instructions="How unsafe is this listing for a general audience?",
+            criteria=["safe", "borderline", "unsafe"],
+        ),
+        fail_at=1.5,
+        model="drex-max",
+        on_fail="exception",
+    )
+)
+
+guard.validate(
+    "Vintage camera, works well.",
+    metadata={"images": ["https://example.com/listing.jpg"]},
+)
+```
+
+### Check one field of structured output
+
+```python
+from pydantic import BaseModel, Field
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Noul
+
+off_topic = DrexPolicy(
+    question=Noul(instructions="Is this reply about something other than our billing product?"),
+    fail_at=0.5,
+    on_fail="exception",
+)
+
+
+class Reply(BaseModel):
+    answer: str = Field(validators=[off_topic])
+
+
+guard = Guard.for_pydantic(output_class=Reply)
+guard.parse('{"answer": "Your invoice is in Settings > Billing."}')
+```
+
+## API reference
+
+**`__init__(self, question, fail_at, fail_when=None, question_id="policy", model=None, client=None, on_fail=None)`**
+<ul>
+
+**Parameters**
+- **`question`** *(nace_sdk.Noul | nace_sdk.Score)*: The question Drex answers about the value. If `instructions` is omitted, it stays `None` and is not sent.
+- **`fail_at`** *(float)*: For a noul, a P(yes) threshold between 0 and 1. For a score, a finite expected-index threshold.
+- **`fail_when`** *(str)*: `"yes"` (default) or `"no"` for a noul. `"at_or_above"` (default) or `"below"` for a score.
+- **`question_id`** *(str)*: Key of the question in the Drex request and response. Default `"policy"`.
+- **`model`** *(str)*: Drex model id. Default `drex-v2.0`. Images need `drex-max`.
+- **`client`** *(nace_sdk.NaceClient)*: An existing client. If omitted, the validator builds one that reads `NACE_API_KEY` and `NACE_BASE_URL`.
+- **`on_fail`** *(str, Callable)*: What Guardrails does on a fail: one of `exception`, `noop`, `reask`, `fix`, `filter`, `refrain` or `fix_reask`, or a function that Guardrails calls on a fail.
+</ul>
+<br/>
+
+**`validate(self, value, metadata) -> ValidationResult`**
+<ul>
+Asks Drex the question about `value` and compares the answer with `fail_at`. Do not call it directly. `guard.parse(...)` and `guard.validate(...)` call it.
+
+If Drex cannot answer (a network error, an API error, or a response without the expected answer), the exception propagates. The validator does not turn it into a pass or a fail.
+
+**Parameters**
+- **`value`** *(str)*: The text to check.
+- **`metadata`** *(dict)*: Optional.
+
+    | Key | Type | Description | Default |
+    | --- | --- | --- | --- |
+    | `images` | list[str] | Image URLs or data URLs. Needs `model="drex-max"`; at most 8. | None |
+
+**Result metadata**
+
+| Key | Description |
+| --- | --- |
+| `drex_model` | Model id sent to Drex |
+| `drex_question_id` | The `question_id` |
+| `drex_answer` | The Drex answer, for example `{"type": "noul", "noul": 0.93}` |
+</ul>
+
+## License
+
+MIT. Copyright (c) 2026 Nace.AI. See [LICENSE](LICENSE).
+
+Scaffolding from [guardrails-ai/validator-template](https://github.com/guardrails-ai/validator-template) (Apache-2.0).

drex_policy-0.1.0/drex_policy/__init__.py

@@ -0,0 +1,3 @@
+from .main import DrexPolicy
+
+__all__ = ["DrexPolicy"]

drex_policy-0.1.0/drex_policy/main.py

@@ -0,0 +1,172 @@
+import math
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any, Protocol
+
+from guardrails.validator_base import (
+    FailResult,
+    PassResult,
+    ValidationResult,
+    Validator,
+    register_validator,
+)
+from nace_sdk import NaceClient, Noul, NoulAnswer, RetryPolicy, Score, ScoreAnswer
+
+VERSION = "0.1.0"
+CLIENT_INFO = f"drex-policy/{VERSION}"
+DEFAULT_MODEL = "drex-v2.0"
+IMAGE_MODEL = "drex-max"
+MAX_IMAGES = 8
+
+Question = Noul | Score
+
+
+class DrexPolicyError(Exception):
+    """Drex could not decide the check. This is not a policy fail."""
+
+
+class SystemOneCaller(Protocol):
+    def system_one(
+        self,
+        state: str,
+        questions: Mapping[str, Question],
+        *,
+        model: str | None = None,
+        images: Sequence[str] | None = None,
+    ) -> Any: ...
+
+
+@register_validator(name="nace/drex_policy", data_type="string")
+class DrexPolicy(Validator):
+    """Validates a string by asking Drex one `noul` or `score` question about it.
+
+    Registered as `nace/drex_policy` for `string` values. It returns no fix value.
+
+    Args:
+        question (Noul | Score): The Drex question asked about the value.
+        fail_at (float): For a noul, the P(yes) threshold in [0, 1]. For a score,
+            the expected-index threshold.
+        fail_when (str): "yes" (default) or "no" for a noul. "at_or_above"
+            (default) or "below" for a score.
+        question_id (str): Key of the question in the Drex request. Default "policy".
+        model (str): Drex model id. Default "drex-v2.0". Images need "drex-max".
+        client (NaceClient): An existing client. Omit it to build one from
+            `NACE_API_KEY` and `NACE_BASE_URL`.
+    """
+
+    def __init__(
+        self,
+        question: Question,
+        fail_at: float,
+        fail_when: str | None = None,
+        question_id: str = "policy",
+        model: str | None = None,
+        client: SystemOneCaller | None = None,
+        on_fail: Callable | None = None,
+        **kwargs: Any,
+    ):
+        if not isinstance(question, (Noul, Score)):
+            raise TypeError("question must be a nace_sdk.Noul or nace_sdk.Score")
+        if not isinstance(question_id, str) or not question_id:
+            raise ValueError("question_id must be a non-empty string")
+        if isinstance(fail_at, bool) or not isinstance(fail_at, (int, float)):
+            raise TypeError("fail_at must be a number")
+        if model is not None and (not isinstance(model, str) or not model):
+            raise ValueError("model must be a non-empty string")
+        if isinstance(question, Noul):
+            fail_when = "yes" if fail_when is None else fail_when
+            if fail_when not in ("yes", "no"):
+                raise ValueError("noul fail_when must be 'yes' or 'no'")
+            if not 0.0 <= fail_at <= 1.0:
+                raise ValueError("noul fail_at must be between 0 and 1")
+        else:
+            fail_when = "at_or_above" if fail_when is None else fail_when
+            if fail_when not in ("at_or_above", "below"):
+                raise ValueError("score fail_when must be 'at_or_above' or 'below'")
+            if not math.isfinite(fail_at):
+                raise ValueError("score fail_at must be finite")
+        super().__init__(
+            on_fail=on_fail,
+            question=question.model_dump(mode="json"),
+            fail_at=fail_at,
+            fail_when=fail_when,
+            question_id=question_id,
+            model=model,
+            **kwargs,
+        )
+        self._question = question
+        self._fail_at = float(fail_at)
+        self._fail_when = fail_when
+        self._question_id = question_id
+        self._model = model
+        self._client = client
+
+    def _get_client(self) -> SystemOneCaller:
+        if self._client is None:
+            self._client = NaceClient(
+                client_info=CLIENT_INFO,
+                timeout=60,
+                retry=RetryPolicy(timeout=180),
+            )
+        return self._client
+
+    def _model_for(self, images: Sequence[str] | None) -> str:
+        if not images:
+            return self._model or DEFAULT_MODEL
+        if self._model != IMAGE_MODEL:
+            requested = self._model or DEFAULT_MODEL
+            raise DrexPolicyError(f"images require model {IMAGE_MODEL!r}, not {requested!r}")
+        if len(images) > MAX_IMAGES:
+            raise DrexPolicyError(f"{IMAGE_MODEL} accepts at most {MAX_IMAGES} images")
+        return IMAGE_MODEL
+
+    def validate(self, value: Any, metadata: dict[str, Any] | None = None) -> ValidationResult:
+        """Asks Drex the question about `value` and compares the answer with `fail_at`."""
+        if not isinstance(value, str):
+            raise TypeError("drex_policy validates a string")
+        images = (metadata or {}).get("images")
+        if images is not None and (
+            isinstance(images, str)
+            or not isinstance(images, (list, tuple))
+            or not all(isinstance(image, str) and image for image in images)
+        ):
+            raise TypeError("metadata['images'] must be a list of non-empty strings")
+        model = self._model_for(images)
+        response = self._get_client().system_one(
+            value,
+            {self._question_id: self._question},
+            model=model,
+            images=list(images) if images else None,
+        )
+        answer = _answer(response, self._question_id, self._question)
+        if isinstance(answer, NoulAnswer):
+            label, measured = "P(yes)", float(answer.noul)
+            fail_low = self._fail_when == "no"
+        else:
+            label, measured = "score", float(answer.score)
+            fail_low = self._fail_when == "below"
+        failed = measured < self._fail_at if fail_low else measured >= self._fail_at
+        result_metadata = {
+            "drex_model": model,
+            "drex_question_id": self._question_id,
+            "drex_answer": answer.model_dump(mode="json"),
+        }
+        if failed:
+            relation = "<" if fail_low else ">="
+            return FailResult(
+                error_message=f"Drex {label}={measured} {relation} fail_at={self._fail_at}",
+                metadata=result_metadata,
+            )
+        return PassResult(metadata=result_metadata)
+
+
+def _answer(response: Any, question_id: str, question: Question) -> NoulAnswer | ScoreAnswer:
+    answers = getattr(response, "answers", None)
+    if not isinstance(answers, Mapping) or question_id not in answers:
+        raise DrexPolicyError(f"Drex response has no answer for {question_id!r}")
+    answer = answers[question_id]
+    expected = NoulAnswer if isinstance(question, Noul) else ScoreAnswer
+    if not isinstance(answer, expected):
+        raise DrexPolicyError(
+            f"Drex answer for {question_id!r} is {type(answer).__name__}, expected {expected.__name__}"
+        )
+    return answer

drex_policy-0.1.0/drex_policy.egg-info/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: drex-policy
+Version: 0.1.0
+Summary: Guardrails validator that checks text, or text with images, against a Drex noul or score question.
+Author-email: "Nace.AI" <alish@nace.ai>
+License-Expression: MIT
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: guardrails-ai>=0.4.0
+Requires-Dist: nace-sdk>=0.6.2
+Provides-Extra: dev
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# drex-policy
+
+A [Guardrails](https://github.com/guardrails-ai/guardrails) validator that asks Drex, Nace.AI's decision model, one question about a string.
+
+| Developed by | Nace.AI |
+| --- | --- |
+| Date of development | Oct 29, 2026 |
+| Validator type | Moderation, policy |
+| License | MIT |
+| Input/Output | Input, Output |
+
+## What it checks
+
+`DrexPolicy` asks [Drex](https://console.nace.ai/docs) one question about a string and fails when the answer crosses a threshold you set. Use it for checks such as PII present, off-topic, toxicity level, jailbreak attempt, or competitor mention.
+
+The question is a `nace_sdk.Noul` (probability of a yes answer) or a `nace_sdk.Score` (expected index over criteria you list). Drex returns the probability. You choose the threshold with `fail_at`, preferably from labeled examples from your application.
+
+- Noul: fails when P(yes) is at or above `fail_at`. With `fail_when="no"`, fails when P(yes) is below `fail_at`.
+- Score: fails when the score is at or above `fail_at`. With `fail_when="below"`, fails when the score is below `fail_at`.
+
+The Drex answer is in the result metadata on pass and on fail.
+
+## Models
+
+The default model is `drex-v2.0`. Text-only checks can use any Drex model id, which is sent unchanged. `drex-latest` is sent as `drex-latest`. It is not `drex-max`.
+
+To check images with the text, pass `model="drex-max"` and put the images in `metadata["images"]`. Each image is a URL or a data URL (PNG, JPEG, or WebP). `drex-max` accepts at most 8 images. If images are present and the model is not `drex-max`, or there are more than 8 images, the validator raises `DrexPolicyError` before it calls Drex. It does not drop the images.
+
+## Requirements
+
+* Dependencies:
+	- guardrails-ai>=0.4.0
+	- nace-sdk>=0.6.2
+
+* Access keys:
+	- `NACE_API_KEY`: a key from [console.nace.ai](https://console.nace.ai)
+	- `NACE_BASE_URL` (optional): defaults to `https://console.nace.ai`
+
+When the validator builds its own client, each HTTP attempt times out after 60 seconds, the total retry budget is 180 seconds, and requests carry `X-Nace-Client: drex-policy/0.1.0`.
+
+## Install
+
+```bash
+$ guardrails hub install hub://nace/drex_policy
+```
+
+You can also install the package from PyPI:
+
+```bash
+$ pip install drex-policy
+```
+
+With a PyPI install, import the validator from `drex_policy` instead of `guardrails.hub`:
+
+```python
+from drex_policy import DrexPolicy
+```
+
+The examples below use the hub import. The class and its arguments are the same.
+
+## Examples
+
+### Check a string
+
+```python
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Noul
+
+guard = Guard().use(
+    DrexPolicy(
+        question=Noul(instructions="Does the text contain a personal phone number or email address?"),
+        fail_at=0.5,
+        on_fail="exception",
+    )
+)
+
+guard.validate("Our office opens at 9am.")  # Validator passes
+guard.validate("Call me on +1 415 555 0100.")  # Validator fails
+```
+
+### Check text with images
+
+```python
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Score
+
+guard = Guard().use(
+    DrexPolicy(
+        question=Score(
+            instructions="How unsafe is this listing for a general audience?",
+            criteria=["safe", "borderline", "unsafe"],
+        ),
+        fail_at=1.5,
+        model="drex-max",
+        on_fail="exception",
+    )
+)
+
+guard.validate(
+    "Vintage camera, works well.",
+    metadata={"images": ["https://example.com/listing.jpg"]},
+)
+```
+
+### Check one field of structured output
+
+```python
+from pydantic import BaseModel, Field
+from guardrails import Guard
+from guardrails.hub import DrexPolicy
+from nace_sdk import Noul
+
+off_topic = DrexPolicy(
+    question=Noul(instructions="Is this reply about something other than our billing product?"),
+    fail_at=0.5,
+    on_fail="exception",
+)
+
+
+class Reply(BaseModel):
+    answer: str = Field(validators=[off_topic])
+
+
+guard = Guard.for_pydantic(output_class=Reply)
+guard.parse('{"answer": "Your invoice is in Settings > Billing."}')
+```
+
+## API reference
+
+**`__init__(self, question, fail_at, fail_when=None, question_id="policy", model=None, client=None, on_fail=None)`**
+<ul>
+
+**Parameters**
+- **`question`** *(nace_sdk.Noul | nace_sdk.Score)*: The question Drex answers about the value. If `instructions` is omitted, it stays `None` and is not sent.
+- **`fail_at`** *(float)*: For a noul, a P(yes) threshold between 0 and 1. For a score, a finite expected-index threshold.
+- **`fail_when`** *(str)*: `"yes"` (default) or `"no"` for a noul. `"at_or_above"` (default) or `"below"` for a score.
+- **`question_id`** *(str)*: Key of the question in the Drex request and response. Default `"policy"`.
+- **`model`** *(str)*: Drex model id. Default `drex-v2.0`. Images need `drex-max`.
+- **`client`** *(nace_sdk.NaceClient)*: An existing client. If omitted, the validator builds one that reads `NACE_API_KEY` and `NACE_BASE_URL`.
+- **`on_fail`** *(str, Callable)*: What Guardrails does on a fail: one of `exception`, `noop`, `reask`, `fix`, `filter`, `refrain` or `fix_reask`, or a function that Guardrails calls on a fail.
+</ul>
+<br/>
+
+**`validate(self, value, metadata) -> ValidationResult`**
+<ul>
+Asks Drex the question about `value` and compares the answer with `fail_at`. Do not call it directly. `guard.parse(...)` and `guard.validate(...)` call it.
+
+If Drex cannot answer (a network error, an API error, or a response without the expected answer), the exception propagates. The validator does not turn it into a pass or a fail.
+
+**Parameters**
+- **`value`** *(str)*: The text to check.
+- **`metadata`** *(dict)*: Optional.
+
+    | Key | Type | Description | Default |
+    | --- | --- | --- | --- |
+    | `images` | list[str] | Image URLs or data URLs. Needs `model="drex-max"`; at most 8. | None |
+
+**Result metadata**
+
+| Key | Description |
+| --- | --- |
+| `drex_model` | Model id sent to Drex |
+| `drex_question_id` | The `question_id` |
+| `drex_answer` | The Drex answer, for example `{"type": "noul", "noul": 0.93}` |
+</ul>
+
+## License
+
+MIT. Copyright (c) 2026 Nace.AI. See [LICENSE](LICENSE).
+
+Scaffolding from [guardrails-ai/validator-template](https://github.com/guardrails-ai/validator-template) (Apache-2.0).

drex_policy-0.1.0/drex_policy.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+drex_policy/__init__.py
+drex_policy/main.py
+drex_policy.egg-info/PKG-INFO
+drex_policy.egg-info/SOURCES.txt
+drex_policy.egg-info/dependency_links.txt
+drex_policy.egg-info/requires.txt
+drex_policy.egg-info/top_level.txt
+tests/test_validator.py

drex_policy-0.1.0/drex_policy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

drex_policy-0.1.0/drex_policy.egg-info/requires.txt

@@ -0,0 +1,7 @@
+guardrails-ai>=0.4.0
+nace-sdk>=0.6.2
+
+[dev]
+pyright
+pytest
+ruff

drex_policy-0.1.0/drex_policy.egg-info/top_level.txt

@@ -0,0 +1 @@
+drex_policy

drex_policy-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "drex-policy"
+version = "0.1.0"
+description = "Guardrails validator that checks text, or text with images, against a Drex noul or score question."
+authors = [{ name = "Nace.AI", email = "alish@nace.ai" }]
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.10,<4"
+dependencies = [
+    "guardrails-ai>=0.4.0",
+    "nace-sdk>=0.6.2",
+]
+
+[project.optional-dependencies]
+dev = ["pyright", "pytest", "ruff"]
+
+[tool.setuptools]
+packages = ["drex_policy"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.pyright]
+include = ["drex_policy"]

drex_policy-0.1.0/setup.cfg

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

drex_policy-0.1.0/tests/test_validator.py

@@ -0,0 +1,161 @@
+import json
+from typing import Any
+
+import pytest
+from guardrails import Guard
+from nace_sdk import Noul, RetryPolicy, Score, SystemOneResponse
+
+from drex_policy import DrexPolicy
+from drex_policy.main import CLIENT_INFO, DrexPolicyError
+
+
+class FakeClient:
+    def __init__(self, answer: dict) -> None:
+        self.answer = answer
+        self.calls: list[Any] = []
+
+    def system_one(self, state, questions, *, model=None, images=None):
+        self.calls.append((state, questions, model, images))
+        return SystemOneResponse.model_validate_json(
+            json.dumps(
+                {
+                    "model": model,
+                    "usage": {"input_tokens": 4, "image_tokens": 0, "output_tokens": 1},
+                    "answers": {"policy": self.answer},
+                }
+            )
+        )
+
+
+def noul(probability: float) -> FakeClient:
+    return FakeClient({"type": "noul", "noul": probability})
+
+
+def score(value: float) -> FakeClient:
+    return FakeClient(
+        {
+            "type": "score",
+            "score": value,
+            "confidence": 0.8,
+            "legend": ["none", "low", "high"],
+            "probabilities": {"0": 0.1, "1": 0.2, "2": 0.7},
+        }
+    )
+
+
+TOXIC = Noul(instructions="Is this text toxic?")
+
+
+def guard(client: FakeClient, model: str | None = None) -> Guard:
+    return Guard().use(
+        DrexPolicy(question=TOXIC, fail_at=0.5, model=model, client=client, on_fail="exception")
+    )
+
+
+def test_pass():
+    client = noul(0.1)
+    result = guard(client).validate("hello")
+    assert result.validation_passed is True
+    assert result.validated_output == "hello"
+    assert client.calls == [("hello", {"policy": TOXIC}, "drex-v2.0", None)]
+
+
+def test_fail():
+    with pytest.raises(Exception) as exc_info:
+        guard(noul(0.9)).validate("you idiot")
+    assert str(exc_info.value) == (
+        "Validation failed for field with errors: Drex P(yes)=0.9 >= fail_at=0.5"
+    )
+
+
+def test_fail_when_no():
+    validator = DrexPolicy(question=TOXIC, fail_at=0.5, fail_when="no", client=noul(0.1))
+    result = validator.validate("hello", {})
+    assert result.outcome == "fail"
+    assert result.error_message == "Drex P(yes)=0.1 < fail_at=0.5"
+
+
+def test_fail_keeps_answer_in_metadata():
+    validator = DrexPolicy(question=TOXIC, fail_at=0.5, client=noul(0.9))
+    result = validator.validate("you idiot", {})
+    assert result.outcome == "fail"
+    assert result.metadata == {
+        "drex_model": "drex-v2.0",
+        "drex_question_id": "policy",
+        "drex_answer": {"type": "noul", "noul": 0.9},
+    }
+
+
+def test_score_at_or_above_and_below():
+    question = Score(instructions="How toxic?", criteria=["none", "low", "high"])
+    high = DrexPolicy(question=question, fail_at=1.5, client=score(2.0))
+    assert high.validate("x", {}).outcome == "fail"
+    below = DrexPolicy(question=question, fail_at=1.5, fail_when="below", client=score(2.0))
+    assert below.validate("x", {}).outcome == "pass"
+
+
+def test_drex_latest_is_forwarded_unchanged():
+    client = noul(0.1)
+    guard(client, model="drex-latest").validate("hello")
+    assert client.calls[0][2] == "drex-latest"
+
+
+def test_images_go_to_drex_max():
+    client = noul(0.1)
+    validator = DrexPolicy(question=TOXIC, fail_at=0.5, model="drex-max", client=client)
+    validator.validate("caption", {"images": ["data:image/png;base64,AAAA"]})
+    assert client.calls[0][2:] == ("drex-max", ["data:image/png;base64,AAAA"])
+
+
+@pytest.mark.parametrize("model", [None, "drex-v2.0", "drex-latest"])
+def test_images_without_drex_max_are_refused(model):
+    client = noul(0.1)
+    validator = DrexPolicy(question=TOXIC, fail_at=0.5, model=model, client=client)
+    with pytest.raises(DrexPolicyError, match="images require model 'drex-max'"):
+        validator.validate("caption", {"images": ["data:image/png;base64,AAAA"]})
+    assert client.calls == []
+
+
+def test_more_than_eight_images_are_refused():
+    client = noul(0.1)
+    validator = DrexPolicy(question=TOXIC, fail_at=0.5, model="drex-max", client=client)
+    with pytest.raises(DrexPolicyError, match="at most 8 images"):
+        validator.validate("caption", {"images": ["data:image/png;base64,AAAA"] * 9})
+    assert client.calls == []
+
+
+def test_omitted_instructions_stay_none():
+    client = noul(0.1)
+    DrexPolicy(question=Noul(), fail_at=0.5, client=client).validate("hello", {})
+    sent = client.calls[0][1]["policy"]
+    assert sent.instructions is None
+    assert sent.model_dump(exclude_none=True) == {"type": "noul"}
+
+
+def test_built_client_settings(monkeypatch):
+    seen = {}
+
+    class Recorder:
+        def __init__(self, **kwargs):
+            seen.update(kwargs)
+
+    monkeypatch.setattr("drex_policy.main.NaceClient", Recorder)
+    DrexPolicy(question=TOXIC, fail_at=0.5)._get_client()
+    assert seen["client_info"] == CLIENT_INFO == "drex-policy/0.1.0"
+    assert seen["timeout"] == 60
+    assert seen["retry"] == RetryPolicy(timeout=180)
+    assert "model" not in seen
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"fail_at": 1.5},
+        {"fail_at": 0.5, "fail_when": "below"},
+        {"fail_at": 0.5, "question_id": ""},
+        {"fail_at": 0.5, "model": ""},
+    ],
+)
+def test_bad_config(kwargs):
+    with pytest.raises(ValueError):
+        DrexPolicy(question=TOXIC, **kwargs)