typos

Author: knielsen404

docs/assets/invariant.css

@@ -14,6 +14,8 @@
 :root {
     --primary-blue: #3d3affac;
     --primary-red: #ff6678;
+    --primary-sand: #f5e9d7;
+    --primary-teal: #00b4a2;
 }
 
 
@@ -443,14 +445,15 @@ span.parser-badge::before {
     position: relative;
     top: -3pt;
     margin-left: 3pt;
-    background-color: #3A99FF;
+    background-color: var(--primary-teal);
     display: inline-block;
     height: 18pt;
 
     padding: 2pt 4pt;
     border-radius: 4pt;
 }
 
+
 .builtin-badge::before {
     content: "Builtin";
     color: #eef2ff;
@@ -492,20 +495,21 @@ span.parser-badge::before {
     content: 'Detectors allow you to detect the presence of certain patterns and types of data in an input.';
 }
 
-.high-latency {
+
+.parser-badge {
     position: relative;
 }
 
-.high-latency:hover::after {
-    content: 'High-Latency checks may significantly increase the time it takes to process a request. Non-blocking checks are recommended.';
+.parser-badge:hover::after {
+    content: 'Parsers allow you to extract specific types of data from an input.';
 }
 
-.parser-badge {
+.high-latency {
     position: relative;
 }
 
-.parser-badge:hover::after {
-    content: 'Parsers allow you to extract specific types of data from an input.';
+.high-latency:hover::after {
+    content: 'High-Latency checks may significantly increase the time it takes to process a request. Non-blocking checks are recommended.';
 }
 
 .builtin-badge {
@@ -521,7 +525,6 @@ span.parser-badge::before {
     padding-top: 0pt !important;
 }
 
-eb279c8597c001a60e752
 .parser-badge:hover::after,
 .detector-badge:hover::after,
 .llm-badge:hover::after,

docs/guardrails/copyright.md

@@ -12,39 +12,39 @@ It is important to ensure that content generated by agentic systems respects int
 !!! danger "Copyright Risks"
     Agents that generate code or other copyrighted material without proper authorization are at risk of violating copyright laws. This could expose your agentic system to legal liability:
 
-    * You agent may handle, process and reproduce copyrighted material without permission
+    * Your agent may handle, process, and reproduce copyrighted material without permission.
 
-    * You may unknowingly host copyrighted material without permission
+    * You may unknowingly host copyrighted material without permission.
 
-    * You may unknowingly expose copyrighted material to users
+    * You may unknowingly expose copyrighted material to users.
 
 
-Guardrails provides the `copyright` function to detect if any licenses are present in a given piece of text, to protect against exactly this.
+Invariant provides the `copyright` function to detect if any licenses are present in a given piece of text, to protect against exactly this.
 
 ## copyright <span class="detector-badge"></span>
 ```python
 def copyright(
-    data: Union[str, List[str]],
-) -> List[str]
+    data: str | list[str],
+) -> list[str]
 ```
 Detects copyrighted text material if it is in `data` and returns the detected licenses.
 
 **Parameters**
 
 | Name        | Type   | Description                            |
 |-------------|--------|----------------------------------------|
-| `data`      | `str | List[str]` |  A single message or a list of messages. |
+| `data`      | `str | list[str]` |  A single message or a list of messages. |
 
 **Returns**
 
 | Type   | Description                            |
 |--------|----------------------------------------|
-| `List[str]` |  List of detected copyright types. For example, `["GNU_AGPL_V3", "MIT_LICENSE", ...]`|
+| `list[str]` |  List of detected copyright types. For example, `["GNU_AGPL_V3", "MIT_LICENSE", ...]`|
 
 ### Detecting copyrighted content
 The simplest use-case of the `copyright` function is to apply it to all messages, as seen below.
 
-**Example:** Detecting copyrighted content
+**Example:** Detecting copyrighted content.
 ```guardrail
 from invariant.detectors import copyright
 

docs/guardrails/explorer.md

@@ -12,7 +12,7 @@ Learn how to configure and manage your guardrailing rules in Explorer.
 
 [Explorer](../explorer/index.md) is Invariant's configuration and observability tool. It allows you to configure guardrails, inspect and debug your agent traces and analyze your agentic system for novel failure modes.
 
-It exposes a simple configuration interface, that allows you to configure, test and deploy guardrails to your agentic system, as well as inspect guardrail failures in detail.
+It exposes a simple configuration interface that allows you to configure, test, and deploy guardrails to your agentic system, as well as inspect guardrail failures in detail.
 
 <figure class="styled-figure">
   <img src="site:/guardrails/guardrails-configuration-explorer.png" alt="Explorer Landing" class="invariant-architecture" style="display: block; margin: 0 auto; width: 100%; max-width: 650pt;"/>
@@ -41,7 +41,6 @@ import os
 from openai import OpenAI
 
 # 1. Explorer+Gateway Integration
-
 client = OpenAI(
     default_headers={
         "Invariant-Authorization": "Bearer " + os.getenv("INVARIANT_API_KEY")
@@ -94,8 +93,8 @@ Here, you can configure the following parameters:
 | Action        | Description                            |
 |---------------|----------------------------------------|
 | Block       | Blocks the request outright, returning an HTTP error to the client. |
-| Log         | Let's the request pass, but logs the violation in Explorer via designated Guardrail violation annotations in the resulting agent traces. This is useful to monitor your agent's violation patterns, without disrupting the agentic process. |
-| Paused      | Pauses the enforcement of the guardrail, allowing all request to pass through without evaluating it. This is useful to temporarily disable a guardrail. |
+| Log         | Lets the request pass, but logs the violation in Explorer via designated Guardrail violation annotations in the resulting agent traces. This is useful to monitor your agent's violation patterns, without disrupting the agentic process. |
+| Paused      | Pauses the enforcement of the guardrail, allowing all requests to pass through without evaluating it. This is useful to temporarily disable a guardrail. |
 
 
 **Guardrailing Rule**: The guardrailing rules that need to be matched for the overall guardrail to be triggered. This is an editor of the Guardrails rule language, providing Invariant's full expressive power as described in this documentation.
@@ -105,7 +104,7 @@ Here, you can configure the following parameters:
 
 To use a pre-defined guardrail, navigate to the bottom part of the Guardrails configuration page.
 
-Here, you will see a list of pre-defined guardrails, along with a short description of the guardrail. These preconfigured rules, are meant to be a starting point for your guardrail configuration. 
+Here, you will see a list of pre-defined guardrails, along with a short description of the guardrail. These preconfigured rules are meant to be a starting point for your guardrail configuration. 
 
 Click on the `Details` button to review and modify any preconfigured rule before deploying it to your project. Each guardrail suggestion comes with comments explaining its functionality. 
 
@@ -115,9 +114,9 @@ Click on the `Details` button to review and modify any preconfigured rule before
 
 All changes made in Explorer are automatically deployed to your Gateway instance, enabling you to deploy new guardrails and security policies within seconds. 
 
-This means, even though your agentic system may be running in a slow-to-update production environment, you can quickly respond to new security threats and update your guardrails to your liking, without having to manually update your agent system or re-deploy.
+This means, that even though your agentic system may be running in a slow-to-update production environment, you can quickly respond to new security threats and update your guardrails to your liking, without having to manually update your agent system or re-deploy.
 
-It also enables quick experimentation with new guardrails, without having to worry about the underlying infrastructure. Gateway will automatically pull the latest guardrail configuration from Explorer once a new version is deployed, updating your agent's behavior in real-time.
+It also enables quick experimentation with new guardrails, without having to worry about the underlying infrastructure. Gateway will automatically pull the latest guardrail configuration from Explorer once a new version is deployed, updating your agent's behavior in real time.
 
 ## Inspecting Guardrail Failures
 

docs/guardrails/gateway.md

@@ -10,7 +10,7 @@ icon: bootstrap/hdd-network
 Learn how Invariant guardrailing rules are enforced and deployed.
 </div>
 
-Invariant is a guardrailing layer, located between you and your LLM and MCP servers. This means, it intercepts, analyzes and secures every LLM and tool interaction of your agentic system, without you having to change your code.
+Invariant is a guardrailing layer, located between you and your LLM and MCP servers. This means it intercepts, analyzes, and, secures every LLM and tool interaction of your agentic system, without you having to change your code.
 
 <br/><br/>
 <img src="site:/guardrails/gateway-integration.svg" alt="Invariant Architecture" class="invariant-architecture" style="display: block; margin: 0 auto; width: 100%; max-width: 300pt;"/>
@@ -20,13 +20,13 @@ To use Invariant, you need to integrate [Invariant Gateway](../gateway/index.md)
 
 ## LLM Proxying and Guardrails
 
-In the case of LLM proxying, gateway will intercept every LLM call of you agent system (including the current agent context), apply the configured guardrailing rules to the input, and then invoke the actual LLM provider.
+In the case of LLM proxying, gateway will intercept every LLM call of your agent system (including the current agent context), apply the configured guardrailing rules to the input, and then invoke the actual LLM provider.
 
 Once the LLM provider returns the response, the gateway will again apply your guardrailing rules to the LLM response, and ensure that the response and its consequence (e.g. tool calls) are safe to execute, according to your guardrails.
 
 **Handling Failure:** In case any of the checks fail, Gateway will return an HTTP error response instead of the LLM response, allowing your agent system to handle the guardrail violation gracefully. 
 
-To help with that, the error response will include information on the violated guardrail, including the specified error message, the violated rule, and the address of the violating components in your agent's context (e.g. messages indices, contents and sub-ranges).
+To help with that, the error response will include information on the violated guardrail, including the specified error message, the violated rule, and the address of the violating components in your agent's context (e.g. messages indices, contents, and sub-ranges).
 
 <br/><br/>
 <img src="site:/guardrails/gateway-llm.svg" alt="LLM Proxying and Guardrails" class="llm-proxying-guardrails" style="display: block; margin: 0 auto; width: 100%; max-width: 400pt;"/>
@@ -39,15 +39,15 @@ In contrast to traditional guardrailing system, Guardrails follows a pipelined a
 <img src="site:/guardrails/pipelined.svg" alt="Pipelining and Incremental Guardrailing" class="pipelining-incremental-guardrails" style="display: block; margin: 0 auto; width: 100%;"/>
 <br/><br/>
 
-As illustrated above, input latency can oftentimes be entirely eliminated by our pipelined execution approach, whereas output latency is greatly reduced, because of Invariant's stateful, cached and pre-computed rule evaluation. Guardrails' rule engine will eagerly pre-compute all matching parts of a rule, such that once the LLM response arrives, only very little checking remains. To achieve this, Guardrails automatically orchestrates rule evaluation, including ML model inference, using an optimized execution graph.
+As illustrated above, input latency can oftentimes be entirely eliminated by our pipelined execution approach, whereas output latency is greatly reduced, because of Invariant's stateful, cached, and pre-computed rule evaluation. Guardrails' rule engine will eagerly pre-compute all matching parts of a rule, such that once the LLM response arrives, only very little checking remains. To achieve this, Guardrails automatically orchestrates rule evaluation, including ML model inference, using an optimized execution graph.
 
 ## Deploying your Guardrails
 
 To deploy your guardrailing rules, you have two options:
 
-<!-- 1. **Stateless via Header**: You can send your guardrailing rules with every LLM call in a desiganted `Invariant-Guardrails` header field.
+<!-- 1. **Stateless via Header**: You can send your guardrailing rules with every LLM call in a designated `Invariant-Guardrails` header field.
 
-2. **Managed Via Exlorer**: You can manage your guardrailing rules via Invariant Explorer. This decouples guardrail management from your agent code, but allows for centralized management of guardrails.  -->
+2. **Managed Via Exlorer**: You can manage your guardrailing rules via Invariant Explorer. This decouples guardrail management from your agent code but allows for centralized management of guardrails.  -->
 
 <div class='tiles'>
 <a href="#via-header" class='tile primary'>
@@ -105,11 +105,11 @@ This snippet demonstrates how to use the managed instance of Gateway, accessible
 
 Apart from this, you can also use a local instance of Gateway, by setting the `base_url` to your local instance. See the [Gateway documentation](../gateway/self-hosted.md) for more details on local deployment.
 
-Passing via header is a stateless approach, meaning that every request will need to include the guardrailing rules. This is useful for quick testing and prototyping, but means that your agentic system must define and send its own guardrailing rules with every request. 
+Passing via header is a stateless approach, meaning that every request will need to include the guardrailing rules. This is useful for quick testing and prototyping but means that your agentic system must define and send its own guardrailing rules with every request. 
 
 <h3 id="via-explorer">Configuring Guardrails via Explorer</h3>
 
-To configure guardrailing rules outside of the actual agentic system, you can use [Invariant Explorer](https://explorer.invariantlabs.ai). This allows you to manage your guardrailing rules in a centralized way, and decouples guardrail management from your agent code. It is also useful, if you do not control the code of the agentic system itself, but want to constrain its behavior.
+To configure guardrailing rules outside of the actual agentic system, you can use [Invariant Explorer](https://explorer.invariantlabs.ai). This allows you to manage your guardrailing rules in a centralized way and decouples guardrail management from your agent code. It is also useful, if you do not control the code of the agentic system itself, but want to constrain its behavior.
 
 Explorer provides a comprehensive user interface to manage and configure your guardrailing rules, including a list of suggested rules, a rule editor, and a rule testing interface.
 

docs/guardrails/images.md

@@ -1,12 +1,12 @@
 ---
 title: Images
-description: Secure images given to, or produced by, your agentic system.
+description: Secure images given to, or produced by your agentic system.
 ---
 
 # Images
 
 <div class='subtitle'>
-Secure images given to, or produced by your agentic system.
+Secure images given to or produced by your agentic system.
 </div>
 
 At the core of computer vision agents is the ability to perceive their environment through images, typically by taking screenshots to assess the current state. This visual perception allows agents to understand interfaces, identify interactive elements, and make decisions based on what they "see."
@@ -19,41 +19,41 @@ Additionally, some systems may allow users to submit images, posing additional r
 
 > * Capture **personally identifiable information (PII)** like names or addresses.
 > 
-> * View credentials such as **passwords, API keys, or access tokens** like present in passport images or other documents.
+> * View credentials such as **passwords, API keys, or access tokens** present in passport images or other documents.
 > 
 > * Get **prompt injected or jailbroken** from text in an image.
 > 
 > * Generate images with **explicit or harmful content**.
 
 
-Guardrails provide you a powerful way to enforce visual security policies, and to limit the agent's perception to only the visual information that is necessary and appropriate for the task at hand.
+Guardrails provide a powerful way to enforce visual security policies, and to limit the agent's perception to only the visual information that is necessary and appropriate for the task at hand.
 
 
 ## ocr <span class="parser-badge"/>
 ```python
 def ocr(
-    data: str, List[str],
-    config: Optional[dict]
-) -> List[str]
+    data: str | list[str],
+    config: dict | None = None
+) -> list[str]
 ```
 Given an image as input, this parser extracts and returns the text in the image using [Tesseract](https://github.com/tesseract-ocr/tesseract).
 
 **Parameters**
 
 | Name        | Type   | Description                            |
 |-------------|--------|----------------------------------------|
-| `data`      | `str, List[str]` | A single base64 encoded image or a list of base64 encoded images. |
+| `data`      | `str | list[str]` | A single base64 encoded image or a list of base64 encoded images. |
 
 **Returns**
 
 | Type   | Description                            |
 |--------|----------------------------------------|
-| `List[str]` | A list of extracted pieces of text from `data`. |
+| `list[str]` | A list of extracted pieces of text from `data`. |
 
 ### Analyzing Text in Images
 The `ocr` function is a  <span class="parser-badge" size-mod="small"></span> so it returns the data found from parsing its content; in this case, any text present in an image will be extracted. The extracted text can then be used for further detection, for example detecting a prompt injection in an image, like the example below.
 
-**Example:** Image Prompt Injection Detection.
+**Example:** Image prompt injection detection.
 ```python
 from invariant.detectors import prompt_injection
 from invariant.parsers import ocr
@@ -70,10 +70,10 @@ raise "Found Prompt Injection in Image" if:
 
 ```python
 def image(
-    content: Content | List[Content]
-) -> List[Image]
+    content: Content | list[Content]
+) -> list[ImageContent]
 ```
-Given some `Content`, this <span class="builtin-badge" size-mod="small"></span> extracts all images. This is useful when messages may contain mixed content.
+Given some [`Content`](/docs-guardrails/guardrails/basics/#message), this <span class="builtin-badge" size-mod="small"></span> extracts all [`ImageContent`](/docs-guardrails/guardrails/basics/#message). This is useful when messages may contain mixed content.
 
 **Parameters**