Open Responses

from qwed_finance import OpenResponsesIntegration

qwed = OpenResponsesIntegration()

# Get OpenAI-compatible tools schema
tools = qwed.get_tools_schema()

# Handle tool call from LLM
result = qwed.handle_tool_call(
    tool_name="calculate_npv",
    arguments={"cashflows": [-1000, 300, 400, 500, 600], "rate": 0.1}
)

print(result.status)  # ToolCallStatus.COMPUTED
print(result.result)  # {"npv": "$388.77", "verified": False, "computed": True, "verified_against_llm": False}

# This tool will be REJECTED: it has no verification function
qwed.register_tool(
    name="transfer_funds",
    description="Transfer money",
    parameters={"amount": {"type": "number"}},
    # Missing verification_fn!
)

result = qwed.handle_tool_call("transfer_funds", {"amount": 999})
# result.status == ToolCallStatus.REJECTED
# result.error == "No verification function registered..."
# result.receipt is not None (rejection is audited)

┌─────────────┐     ┌─────────────┐     ┌─────────────────┐
│    LLM       │────▶│    QWED     │────▶│  Verified Result │
│  Tool Call   │     │  Intercept  │     │  (with receipt)  │
└─────────────┘     └─────────────┘     └─────────────────┘
                          │
                  Has verification_fn?
                    ╱           ╲
                  YES            NO
                   │              │
              Execute fn      REJECTED
              (try/except)    (audited)
                   │
            Return result
         APPROVED / COMPUTED

result = qwed.handle_tool_call("price_option", {
    "spot_price": 100,
    "strike_price": 100,
    "time_to_expiry": 1.0,
    "risk_free_rate": 0.05,
    "volatility": 0.2,
    "option_type": "call",
})

print(result.result["price"])  # "$10.45": mpmath, rounded to cents
print(result.result["delta"])  # "0.6368": a Decimal-quantized string

# Handle tool call
result = qwed.handle_tool_call("calculate_npv", args)

# Format as Open Responses Item
item = qwed.format_for_responses_api(result, tool_call_id="call_abc123")

{
  "type": "tool_result",
  "id": "call_abc123",
  "tool_use_id": "calculate_npv",
  "content": {
    "mime_type": "application/json",
    "text": "{\"result\": {\"npv\": \"$388.77\", \"verified\": false, \"computed\": true, \"verified_against_llm\": false}, \"verification\": {\"status\": \"computed_only\", \"verified\": false, \"note\": \"Result was computed deterministically but NOT verified against an LLM claim.\", \"engine\": \"SymPy\", \"receipt_id\": \"abc-123\", \"input_hash\": \"...\", \"timestamp\": \"2026-01-18T14:30:00.123456+00:00\"}}"
  },
  "is_error": false
}

{
  "type": "tool_result",
  "id": "call_abc123",
  "tool_use_id": "my_custom_tool",
  "content": {
    "mime_type": "application/json",
    "text": "{\"result\": {...}, \"verification\": {\"status\": \"verified\", \"verified\": true, \"engine\": \"Z3\", \"receipt_id\": \"def-456\", \"input_hash\": \"...\", \"timestamp\": \"...\"}}"
  },
  "is_error": false
}

from openai import OpenAI
from qwed_finance import OpenResponsesIntegration, ToolCallStatus

client = OpenAI()
qwed = OpenResponsesIntegration()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Calculate NPV of $1000 investment"}],
    tools=qwed.get_tools_schema(),  # QWED verified tools
    tool_choice="auto"
)

# Intercept and verify tool calls
for tool_call in response.choices[0].message.tool_calls:
    verified = qwed.handle_tool_call(
        tool_call.function.name,
        tool_call.function.arguments
    )
    
    if verified.status == ToolCallStatus.COMPUTED:
        print(f"Computed: {verified.result}")
    elif verified.status == ToolCallStatus.APPROVED:
        print(f"Verified: {verified.result}")
    else:
        print(f"Failed: {verified.error}")

from decimal import Decimal
from qwed_finance import VerifiedToolCall, ToolCallStatus

def verify_my_calculation(args):
    # Recompute the value, then compare it with the model's claim.
    computed = do_deterministic_math(args)  # returns a Decimal
    claimed = args.get("claimed_value")
    if claimed is None or Decimal(str(claimed)) != computed:
        return VerifiedToolCall(
            status=ToolCallStatus.REJECTED,
            tool_name="my_tool",
            original_args=args,
            error=f"claimed {claimed}, computed {computed}",
        )
    return VerifiedToolCall(
        status=ToolCallStatus.APPROVED,
        tool_name="my_tool",
        original_args=args,
        verified_args=args,
        result={"value": str(computed)},
    )

qwed.register_tool(
    name="my_tool",
    description="My custom calculation",
    parameters={
        "type": "object",
        "properties": {
            # ...the inputs do_deterministic_math(args) reads...
            "claimed_value": {
                "type": "string",
                "description": "The value the model claims, checked against the computed one",
            },
        },
        "required": ["claimed_value"],  # plus the inputs your calculation needs
    },
    verification_fn=verify_my_calculation  # Required!
)

# Get all receipts
summary = qwed.audit_log.summary()

# Export for compliance
json_log = qwed.audit_log.export_json()