Spend controls for OpenAI Responses API tools

The OpenAI Responses API exposes function tools on a streaming response object. Paybond does not ship a dedicated Responses adapter; use the agent-agnostic path: wrap { name, execute } handlers and map Responses tool calls to Paybond envelopes at execute time. spend verify runs before side effects; auto-evidence fires after success.

TypeScript and Python — same agent-agnostic instrument() contract in both Kit languages.

Adapter reference: /docs/kit/agent-agnostic.

• Tool boundary, not model middleware

  Guard function tool execute — keep openai.responses.create for inference.

• Agent-agnostic wrap

  Map Responses function_call items to Paybond { name, execute } envelopes.

• Auto-evidence

  Wrapped execute finalizes spend and submits signed evidence after success.

• TypeScript and Python

  Agent-agnostic instrument() in both Kit languages — map Responses function_call items the same way.

Why Paybond (not just Responses API)?

Responses API function tools do not enforce a spend limit, a per-operation permission check (capability token), or a signed completion receipt tied to a spend agreement (intent).

How it works

3-minute quickstart

Smoke the generic sandbox contract used by Responses API wiring:

paybond login
paybond agent demo generic smoke \
  --operation paid-tool \
  --requested-spend-cents 100 \
  --evidence-preset cost_and_completion \
  --format table

paybond login
paybond agent demo generic smoke \
  --operation paid-tool \
  --requested-spend-cents 100 \
  --evidence-preset cost_and_completion \
  --format table

When the smoke succeeds you should see:

• ✓ Spend approved
• ✓ Tool completed
• ✓ Evidence verified (cost_and_completion)

What success looks like

Scaffold

paybond policy init --preset saas --out paybond.policy.yaml
paybond policy validate-tools --file paybond.policy.yaml --local-only

paybond policy init --preset saas --out paybond.policy.yaml
paybond policy validate-tools --file paybond.policy.yaml --local-only

Wire middleware

import OpenAI from "openai";
import { Paybond } from "@paybond/kit";

const openai = new OpenAI();
const paybond = await Paybond.open({ apiKey: process.env.PAYBOND_API_KEY! });

const { tools } = await paybond.instrument({
  policy: "./paybond.policy.yaml",
  tools: {
    "saas.provision_seat": provisionSeat,
    "saas.list_plans": listPlans,
  },
});

const toolByName = new Map(tools.map((t) => [t.name, t]));

const response = await openai.responses.create({
  model: "gpt-4.1",
  tools: [
    {
      type: "function",
      name: "saas.provision_seat",
      description: "Provision a SaaS seat",
      parameters: {
        type: "object",
        properties: {
          planId: { type: "string" },
          priceCents: { type: "integer" },
        },
        required: ["planId", "priceCents"],
      },
    },
  ],
  input: "Provision a starter seat for acme-corp.",
});

// When the response includes a function_call output item:
for (const item of response.output) {
  if (item.type === "function_call" && item.name === "saas.provision_seat") {
    const wrapped = toolByName.get(item.name)!;
    const args = JSON.parse(item.arguments);
    const result = await wrapped.execute({
      toolName: item.name,
      toolCallId: item.call_id ?? item.id,
      arguments: args,
    });
    // Feed result back into a follow-up responses.create call
  }
}

import OpenAI from "openai";
import { Paybond } from "@paybond/kit";

const openai = new OpenAI();
const paybond = await Paybond.open({ apiKey: process.env.PAYBOND_API_KEY! });

const { tools } = await paybond.instrument({
  policy: "./paybond.policy.yaml",
  tools: {
    "saas.provision_seat": provisionSeat,
    "saas.list_plans": listPlans,
  },
});

const toolByName = new Map(tools.map((t) => [t.name, t]));

const response = await openai.responses.create({
  model: "gpt-4.1",
  tools: [
    {
      type: "function",
      name: "saas.provision_seat",
      description: "Provision a SaaS seat",
      parameters: {
        type: "object",
        properties: {
          planId: { type: "string" },
          priceCents: { type: "integer" },
        },
        required: ["planId", "priceCents"],
      },
    },
  ],
  input: "Provision a starter seat for acme-corp.",
});

// When the response includes a function_call output item:
for (const item of response.output) {
  if (item.type === "function_call" && item.name === "saas.provision_seat") {
    const wrapped = toolByName.get(item.name)!;
    const args = JSON.parse(item.arguments);
    const result = await wrapped.execute({
      toolName: item.name,
      toolCallId: item.call_id ?? item.id,
      arguments: args,
    });
    // Feed result back into a follow-up responses.create call
  }
}

Mapping rules

1. Register every side-effecting function name in paybond.policy.yaml with matching tools.* entries.
2. Use the Responses call_id (or stable id) as toolCallId in the Paybond envelope.
3. Read-only tools can omit Paybond wrapping or stay unregistered with default_deny: false only when you accept the risk.

OpenAI Agents SDK vs Responses API

Choose the Agents SDK adapter when you use Runner.run and FunctionTool; use this guide when you integrate directly against Responses function tools.

Production checklist

Works with

Ready to test?

Related guides

• Agent-agnostic spend controls — default { name, execute } wiring
• OpenAI Agents SDK spend controls — native adapter
• Agent middleware — production bind

Developer reference: /docs/kit/agent-agnostic.