QWED Open Responses troubleshooting

pip install qwed-open-responses

pip install qwed-open-responses[langchain]
pip install qwed-open-responses[openai]
pip install qwed-open-responses[all]

pip install qwed-open-responses[langchain]
# or
pip install langchain langchain-openai

# Wrong - no guards, always fails closed
verifier = ResponseVerifier()
result = verifier.verify(response)  # verified=False

# Right - set default guards
verifier = ResponseVerifier(default_guards=[ToolGuard(), SafetyGuard()])

# Or pass guards per call
result = verifier.verify(response, guards=[ToolGuard()])

result = verifier.verify_structured_output(
    output=my_output,
    schema=my_schema,  # or guards=[SchemaGuard(schema=my_schema)]
)

verifier = ResponseVerifier(
    default_guards=[MathGuard(), SafetyGuard()],
    allow_warnings=False,  # warnings now fail (and block in strict mode)
)

from jsonschema import validate, ValidationError

try:
    validate(output, schema)
except ValidationError as e:
    print(f"Field: {e.path}")
    print(f"Error: {e.message}")

guard = SchemaGuard(schema, allow_additional_properties=True)

const guard = new SchemaGuard(schema, { allowAdditionalProperties: true });

print(f"Blocked tool: {result.tool_name}")
print(f"Blocklist: {tool_guard.blocklist}")

# Whitelist mode
tool_guard = ToolGuard(
    whitelist=["calculator", "search", "read_file"],
    allow_unknown=False
)

# Only run MathGuard where math is expected
math_verifier = ResponseVerifier(default_guards=[MathGuard()])
text_verifier = ResponseVerifier(default_guards=[SafetyGuard()])

result = math_guard.verify(output)
if not result.verified:
    print(f"Operation: {result.operation}")
    print(f"Expected: {result.expected}")
    print(f"Got: {result.actual}")

safety_guard = SafetyGuard(
    block_pii=False,
    redact_pii=True,
    custom_patterns=[
        r"EMPLOYEE-\d{6}",  # Internal ID
    ]
)

print(f"From: {from_state}")
print(f"To: {to_state}")
print(f"Valid transitions: {state_guard.valid_transitions[from_state]}")

# Wrong
executor = AgentExecutor(agent=agent, tools=tools)

# Right
executor = AgentExecutor(
    agent=agent,
    tools=tools,
    callbacks=[QWEDCallbackHandler(...)]  # Must include!
)

callback = QWEDCallbackHandler(
    log_verifications=True,  # Enable logging
    guards=[...]
)

# Wrong - uses standard client
from openai import OpenAI
client = OpenAI()

# Right - uses verified wrapper
from qwed_open_responses.middleware.openai_sdk import VerifiedOpenAI
client = VerifiedOpenAI(guards=[...])

response = client.chat.completions.create(
    model="gpt-4",
    messages=[...],
    tools=tools,
    tool_choice="auto"  # Must enable tools
)

import express from 'express';
import { ToolGuard, verifyRequestBody } from 'qwed-open-responses';

const app = express();
app.use(express.json());           // Parse the body first
app.use(verifyRequestBody({ guards: [new ToolGuard()] }));

# Guards run in order
verifier = ResponseVerifier(guards=[
    SchemaGuard(schema),  # First
    ToolGuard(blocklist), # Second
    SafetyGuard(),        # Last
])

# Empty blocklist won't block anything
tool_guard = ToolGuard(blocklist=[])  # Does nothing!

# Fix
tool_guard = ToolGuard(blocklist=["dangerous_tool"])

# Only essential guards
verifier = ResponseVerifier(guards=[
    ToolGuard(blocklist),  # Fast
    # Skip MathGuard for non-math outputs
])

# Parse schema once
from functools import lru_cache

@lru_cache
def get_schema_guard(schema_name):
    return SchemaGuard(schema=SCHEMAS[schema_name])

safety_guard = SafetyGuard(
    pii_patterns=[
        r"\b\d{3}-\d{2}-\d{4}\b",  # Only SSN, not dates
    ]
)

math_guard = MathGuard(tolerance=0.01)  # Allow 1 cent difference