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

pip install qwed-open-responses[openai]

---

​

Quick start

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)

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).

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 for details.

---

​

Structured outputs

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

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

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

# 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.

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)

# 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

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}")