> ## Documentation Index
> Fetch the complete documentation index at: https://docs.qwedai.tech/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenAI integration for verified AI agents

> Use the VerifiedOpenAI wrapper to add verified tool calls, structured output validation, and deterministic guards to OpenAI Assistants and agent workflows.

QWED Open Responses provides a verified wrapper for the OpenAI SDK.

***

## Installation

```bash theme={null}
pip install qwed-open-responses[openai]
```

***

## Quick start

```python theme={null}
from qwed_open_responses.middleware.openai_sdk import VerifiedOpenAI
from qwed_open_responses import ToolGuard, SchemaGuard

# Create verified client
client = VerifiedOpenAI(
    api_key="sk-...",
    guards=[ToolGuard(), SchemaGuard(schema=my_schema)],
)

# Responses are automatically verified
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello"}],
)

# Check verification result
print(response._qwed_verification.verified)
```

<Warning>
  Always pass at least one guard. `VerifiedOpenAI` without `guards` emits a `UserWarning` at construction: verification is fail-closed, so with zero guards every response fails verification and either raises `ResponseBlocked` (`block_on_failure=True`) or is returned unverified (`block_on_failure=False`).
</Warning>

The attached `_qwed_verification` result also exposes:

* `warnings`: guard results that passed with warning severity
* `request_id`: correlation ID when a `request_id` was supplied in the verification context
* `binding` and `verify_binding()`: tamper-evidence tying the result to the exact response and guard list
* `timestamp`: timezone-aware UTC timestamp with the `+00:00` offset

See the [guards reference](/open-responses/guards#combining-guards) for details.

***

## Structured outputs

```python theme={null}
from qwed_open_responses import SchemaGuard

# Define expected schema
order_schema = {
    "type": "object",
    "properties": {
        "product": {"type": "string"},
        "quantity": {"type": "integer", "minimum": 1},
        "price": {"type": "number", "minimum": 0},
    },
    "required": ["product", "quantity", "price"]
}

client = VerifiedOpenAI(
    api_key="sk-...",
    guards=[SchemaGuard(schema=order_schema)],
)

response = client.chat.completions.create(
    model="gpt-4",
    messages=[...],
    response_format={"type": "json_object"},
)
# If output doesn't match schema: ResponseBlocked exception
```

***

## Tool calling verification

```python theme={null}
from qwed_open_responses import ToolGuard

client = VerifiedOpenAI(
    api_key="sk-...",
    guards=[
        ToolGuard(
            allowed_tools=["get_weather", "search"],
            blocked_tools=["execute_code"],
        )
    ],
)

response = client.chat.completions.create(
    model="gpt-4",
    messages=[...],
    tools=[...],
)
# Tool calls are verified before returning
```

***

## Handling blocked responses

```python theme={null}
from qwed_open_responses.middleware.openai_sdk import ResponseBlocked

try:
    response = client.chat.completions.create(...)
except ResponseBlocked as e:
    print(f"Response blocked: {e.result.block_reason}")
    
    # Access the original response
    original = e.response
    
    # Access verification details
    for guard_result in e.result.guard_results:
        if not guard_result.passed:
            print(f"  - {guard_result.guard_name}: {guard_result.message}")
```

***

## Non-blocking mode

```python theme={null}
# Don't raise exceptions, just mark results
client = VerifiedOpenAI(
    api_key="sk-...",
    guards=[ToolGuard()],
    block_on_failure=False,  # Don't raise exceptions
)

response = client.chat.completions.create(...)

# Check verification manually
if response._qwed_verification.verified:
    process(response)
else:
    handle_failure(response._qwed_verification)
```

***

## Budget limits with verification context

Pass `verification_context` to `chat.completions.create()` or `responses.create()` to give guards trusted usage totals, such as the running `total_cost` and `total_tokens` for a session. `VerifiedOpenAI` removes `verification_context` from the request before calling OpenAI, so it never reaches the API. The context is then passed to every guard when the response is verified.

```python theme={null}
from qwed_open_responses import SafetyGuard
from qwed_open_responses.middleware.openai_sdk import VerifiedOpenAI, ResponseBlocked

client = VerifiedOpenAI(
    api_key="sk-...",
    guards=[SafetyGuard(max_cost=10.0, max_tokens=50_000)],
)

try:
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": "Summarize this report"}],
        verification_context={"total_cost": 9.50, "total_tokens": 48_000},
    )
except ResponseBlocked:
    # Response pushed the totals past a SafetyGuard budget limit
    ...
```

You can also call `client.verify(response, context={...})` directly.

***

## Responses API (preview)

```python theme={null}
# For the new OpenAI Responses API (when available)
client = VerifiedOpenAI(api_key="sk-...")

response = client.responses.create(
    model="gpt-4",
    input="Search for weather in NYC",
    tools=[{"type": "web_search"}],
)
# Automatically verified
```

***

## Full example

```python theme={null}
from qwed_open_responses.middleware.openai_sdk import VerifiedOpenAI, ResponseBlocked
from qwed_open_responses import ToolGuard, SchemaGuard, SafetyGuard

# Create client with multiple guards
client = VerifiedOpenAI(
    api_key="sk-...",
    guards=[
        ToolGuard(blocked_tools=["execute_shell"]),
        SchemaGuard(schema=output_schema),
        SafetyGuard(check_pii=True),
    ],
)

try:
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "user", "content": "Process this order"}
        ],
        tools=available_tools,
    )
    
    print("✅ Response verified!")
    print(f"Guards passed: {response._qwed_verification.guards_passed}")
    
except ResponseBlocked as e:
    print(f"❌ Blocked: {e.result.block_reason}")
```


## Related topics

- [QWED Open Responses guards for verified AI agents](/open-responses/guards.md)
- [QWED Open Responses: verified tool calls for AI agents](/open-responses/overview.md)
- [LangChain integration for verified AI agents](/open-responses/langchain.md)
- [QWED Open Responses examples for verified AI agents](/open-responses/examples.md)
- [LLM verification with formal methods](/advanced/llm-verification.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.