# Agent Utilities: public content

Reading this document is free. Tool execution uses prepaid service credits. Current availability: https://agent-utilities.agent-utilities.workers.dev/billing/api/status

---

## Structured discovery

GET https://agent-utilities.agent-utilities.workers.dev/v1/content/index for resource links, or GET https://agent-utilities.agent-utilities.workers.dev/v1/content for this material as JSON. No key is needed for these reads.

---

# Agent Utilities in VS Code

Use Agent Utilities with VS Code's built-in MCP support and a chat session that supports MCP tools. Node.js 22+ and npm/npx must be on the machine where the server runs. The configuration downloads the standalone adapter from a GitHub source archive pinned to release 0.3.0's commit. It does not install an npm registry package.

## Install

Open the [VS Code setup section](https://agent-utilities.agent-utilities.workers.dev/integrations/mcp#vscode) and select **Set up in VS Code**. Your browser may ask to open the desktop application. Review the configuration, choose where to install it and confirm trust before starting the server. The link contains a private-input placeholder, never a credential. It does not approve tool execution or purchase credits.

If the link does not open your application, download [the VS Code configuration](https://agent-utilities.agent-utilities.workers.dev/downloads/vscode-mcp.json). Run **MCP: Open User Configuration** in VS Code's Command Palette. Merge the downloaded `inputs` and `servers` entries with your existing configuration; do not overwrite other servers. For a project-specific installation, merge into `.vscode/mcp.json`. This uses `servers`, unlike the `mcpServers` format used by some other clients.

When prompted, leave the API key empty to discover the tools for free. To execute paid calls, create an account in the [API workspace](https://agent-utilities.agent-utilities.workers.dev/billing), save both credentials privately and fund service credits. Enter only the API key in VS Code's private input prompt; keep the account recovery credential separate. VS Code stores the input for reuse. If you previously left it blank, edit that stored input before restarting the server. Never paste a key into chat, the install URL or a shared configuration file.

## A first task

Start the server using **MCP: List Servers**, then choose its tools in Chat's tool picker. For a first paid task, ask:

> Use commerce_gtin_validate once to check barcode 036000291452.

Review the tool and price before approving execution. That tool costs $0.0003 per successful call; credit funding starts at $5. Keep per-tool approvals enabled. Adapter 0.3.0 caps each new debit at its startup catalog price, but it has no total session budget and never automatically buys credits. Each new call is a new billable operation.

For an uncertain result, preserve the returned request ID and original input. Use `agent_utilities_retry` within ten minutes. The helper can recover an existing matching request without authorizing a new reservation; it cannot cancel a previous reservation. Do not repeat the original tool with a new ID to recover it.

## Compatibility and verification

This configuration targets VS Code's built-in MCP support. It does not configure separate third-party chat extensions. VS Code documents that interactive input variables are not forwarded to Agent Host sessions; use a supported built-in session for this prompted setup. Browser-only clients also need an environment capable of launching the local Node.js process. For remote workspaces, install Node/npm where the MCP server will actually run.

The encoded link, configuration fields and pinned command are checked. The official MCP SDK verifies startup, tool discovery and rejection of execution without an API key. Actual VS Code application installation and chat execution have not been tested; no VS Code Marketplace listing or endorsement is claimed. No live paid requests are used for these checks.

References: [VS Code installation links](https://code.visualstudio.com/api/extension-guides/ai/mcp), [configuration and private inputs](https://code.visualstudio.com/docs/agents/reference/mcp-configuration), [adding and managing servers](https://code.visualstudio.com/docs/agent-customization/mcp-servers).


---

# Use Agent Utilities from Python

Use Python 3.10 or newer with the standard library client. No pip package, Node runtime or MCP process is required. Discovery and documentation are free; tool execution spends existing prepaid credits. This client cannot purchase credits, automatically top up or place merchant orders.

Download `agent_utilities.py`, `agent_utilities.py.sha256` and `agent_utilities_example.py` from `/integrations/python`, or use `examples/python` in the [public repository](https://github.com/cgvhbjk/agent-utilities-mcp/tree/main/examples/python). Keep the two Python files in the same directory. The client is MIT licensed; the license does not provide free hosted execution.

Verify the client, then preview the supplied barcode example without a network request or API key:

```sh
shasum -a 256 -c agent_utilities.py.sha256
python3 agent_utilities_example.py
```

The preview describes a possible request; it does not validate the barcode. The example's `--discover` option reads public content without authentication or payment.

## Discover contracts without a key

```python
from agent_utilities import Client

client = Client()
catalog = client.catalog()  # Free GET /v1/content; no Authorization header
status = client.status()    # Free current payment mode and capabilities
```

The catalog contains schemas, prices, examples, workflows and documentation. All operations are bounded; follow each tool's input contract. This client transports JSON but does not locally implement the full JSON Schema validator. The service validates inputs before execution.

## Prepare once, execute explicitly

Create and save your API and recovery credentials in the [workspace](https://agent-utilities.agent-utilities.workers.dev/billing), and buy credits only when you have useful work to run. Give your process only the API key through private environment configuration. Never include keys in source, command-line arguments, logs or agent prompts.

```python
import os
from agent_utilities import Client, prepare_call, CallError

client = Client(os.environ['AGENT_UTILITIES_API_KEY'])
call = prepare_call(
    'commerce.gtin-validate',
    {'code': '036000291452'},
    max_price_micro_usd=300,  # Maximum new debit: $0.0003
)
# Retain `call` before sending: it contains the fixed input, ID and ceiling.
try:
    response = client.execute(call)
except CallError as error:
    # error.call is the SAME prepared operation, including its request ID.
    # Stop new work, inspect error.code, and recover this call if appropriate.
    # Do not prepare a replacement operation after an uncertain outcome.
    raise
```

A successful response contains `result`, `receipt.chargedMicroUsd` and `recoveryExpiresAt`. The client checks mode and the server's price-limit capability before a paid call. Every new call must specify an integer ceiling from zero to 999999999999. HTTP 412 rejects a new reservation above that ceiling; the client never raises it automatically.

The example script's `--execute` option explicitly authorizes the supplied barcode call, capped at 300 micro-dollars. Each new script run creates a new request ID, so **do not rerun that command to recover a lost response**.

## Retry without a new charge identity

`execute(call)` makes at most two HTTP attempts for uncertain transport/server failures. Both use the same bytes, ID and ceiling. It rejects redirects and sends credentials only to the fixed service origin. Ordinary 4xx errors stop without automatic retry; HTTP 408 may be retried once.

If the outcome remains uncertain, preserve the `CallError.call` object. Retry with `client.execute(call)` within ten minutes, after addressing any returned error. A completed operation returns its stored result without another debit. A request that never arrived can execute and debit once up to its ceiling. A rejected retry does not prove that an earlier attempt was uncharged. Expired recovery requires checking the balance or contacting support before repeating work.

For recovery after a process restart, supply the original `request_id` to `prepare_call` with the same tool, input and ceiling. Persist these values privately before executing if your application needs crash recovery. They can contain sensitive input. The library does not write a journal or store credentials on disk, and it cannot recover an ID your application lost.

A ceiling of zero permits recovery of a matching existing reservation without authorizing a new debit. It does not refund or cancel a previous charge. Server recovery still binds the same tool version, price and input. Read the [developer quickstart](https://agent-utilities.agent-utilities.workers.dev/quickstart) for service limits and recovery details.

## Shopping example: choose whole packs

Download [pack_plan_example.py](https://agent-utilities.agent-utilities.workers.dev/downloads/pack_plan_example.py), [pack_plan_cases.json](https://agent-utilities.agent-utilities.workers.dev/downloads/pack_plan_cases.json) and their [script checksum](https://agent-utilities.agent-utilities.workers.dev/downloads/pack_plan_example.py.sha256) and [data checksum](https://agent-utilities.agent-utilities.workers.dev/downloads/pack_plan_cases.json.sha256). Keep them beside `agent_utilities.py`. They are also in the public repository's `examples/python` directory.

```sh
shasum -a 256 -c pack_plan_example.py.sha256
shasum -a 256 -c pack_plan_cases.json.sha256
python3 pack_plan_example.py
python3 pack_plan_example.py --scenario limited-stock
python3 pack_plan_example.py --scenario insufficient-stock
```

These commands make no network requests. They print fixed sample inputs and expected result subsets, not computed answers or evidence of a hosted execution. The three fixtures illustrate twelve interchangeable units: two six-packs cost $15.98; with only one six-pack available, a six-pack plus a ten-pack costs $19.98; with only one six-pack and no ten-packs available, the request is infeasible. Prices and inventory are fictional.

To execute one selected scenario using existing credits, set `AGENT_UTILITIES_API_KEY` privately and add `--execute`. A new call is capped at $0.0008. A valid infeasible result is also billable. Funding starts with a $5 credit pack, but no payment or account is needed to inspect these examples.

The script prints the request ID and exact input before execution. Retain them privately if execution needs recovery; rerunning the script creates a new billable identity. Use the original ID and input with `prepare_call` and `Client.execute` as described above. The example does not buy credits or place orders, verify stock, or account for shipping, tax or product equivalence. See the [whole-pack workflow](https://agent-utilities.agent-utilities.workers.dev/use-cases/choose-whole-packs) before adapting it.

## Compare delivered checkout totals

Download [compare_carts.py](https://agent-utilities.agent-utilities.workers.dev/downloads/compare_carts.py) and [cart_comparison_example.json](https://agent-utilities.agent-utilities.workers.dev/downloads/cart_comparison_example.json), plus their [script checksum](https://agent-utilities.agent-utilities.workers.dev/downloads/compare_carts.py.sha256) and [input checksum](https://agent-utilities.agent-utilities.workers.dev/downloads/cart_comparison_example.json.sha256). Keep them beside `agent_utilities.py`. These files also live in the public repository's `examples/python` folder.

```sh
shasum -a 256 -c compare_carts.py.sha256
shasum -a 256 -c cart_comparison_example.json.sha256
python3 compare_carts.py
```

The default command is offline. It validates the supplied inputs and prints the planned requests and price ceilings; it does not calculate the checkout totals, use a key or contact the service. The fictional example compares identical items: an $18 item plus $5.99 shipping and $1.50 tax totals $25.49; a $22 item with a $1 discount, free shipping and $1.50 tax totals $22.50. The second cart has the lower delivered total despite its higher item price.

Use `--input your-carts.json` for 2–10 comparable checkout snapshots. Follow the sample structure, use unique cart IDs, declare one currency and decimal scale, and supply explicit line and order discounts. Each line discount applies once to the entire line. Set unknown shipping, tax or fees to `null`, never zero. Establish equivalent products, quantities and eligible discounts before comparison. The recipe does not verify those facts, fetch merchant data or calculate taxes from local law.

Add `--execute` only when you want paid execution using existing credits. It sends one `commerce.price-components` call per cart, each capped at $0.0005. The default total ceiling is $0.001 for two carts; for three carts, explicitly supply `--max-total-micro-usd 1500`. The maximum is 5000 micro-dollars ($0.005) for ten carts. A candidate count exceeding the chosen ceiling is rejected before any requests. An unknown-cost result is still a successful, billable reconciliation.

The output retains every known subtotal and missing component. `completeRanking` orders only fully supplied checkout totals using exact integers. `cheapestCompleteIds` includes ties among complete carts; `overallCheapestIds` is `null` whenever any candidate is incomplete. It will not silently recommend a merchant by treating missing tax or shipping as free. A declared-total mismatch is reported alongside the computed total for review.

The script prints every prepared ID and exact input before execution, then emits each successful response and receipt. Preserve this plan privately: it may contain your shopping data. If any call fails or returns an unexpected result, later calls stop; earlier completed calls remain charged. This is not an atomic transaction. **Do not rerun `--execute` to recover an uncertain result.** Use the original tool, input and request ID from the printed plan with `prepare_call` and `Client.execute` within ten minutes, as described above. The recipe creates no durable journal, buys no credits and places no merchant orders.


---

# Agent Utilities developer quickstart

Bounded tools for HTML, JSON, agent configuration, security indicators and product data. Read /v1/tools for the current catalog. Prices are experimental, from $0.0003 to $0.002 per call. Stripe-funded live service credits are enabled. Check /billing/api/status for the current mode before purchasing.

## Use Python directly

The standard-library Python 3.10+ client at /integrations/python provides free discovery, explicit prepaid price ceilings and stable retry identities. No pip install, Node or MCP process is needed. Prepare each logical call once and preserve it for recovery.

## Use an ordinary MCP client

Read /integrations/mcp and download the bundled Node.js 22+ stdio adapter. Configure AGENT_UTILITIES_API_KEY privately in its process environment. It handles authorization, stable request IDs, and one automatic retry. Tool discovery needs no key; execution spends prepaid credits. Use agent_utilities_retry with the returned requestId and unchanged tool name and arguments after an uncertain outcome. No card purchases or automatic top-ups occur through the adapter.

## Public content API

GET /v1/content/index lists machine-readable material; GET /v1/content returns complete JSON including tool contracts, examples, workflows and documentation. GET /llms-full.txt provides the text version. All are free, require no key and permit cross-origin browser reads. Individual resources are /v1/content/tools/<id>, /v1/content/workflows/<slug> and /v1/content/docs/<id>. This reads documentation; executing tools spends service credits.

### Identify a custom HTTP client

Send an honest application `User-Agent`, such as `MyShoppingAgent/1.0`. The provided Python client already does this. A live check on the current workers.dev host found that Python's default `Python-urllib/3.14` signature receives HTTP 403 with Cloudflare error 1010 before the application responds; the identified Python client and tested requests, Node, Axios and Go signatures returned 200. This is an edge compatibility issue, not a request for a payment or API key. Do not send credentials to troubleshoot a public read.

```python
import json
import urllib.request

request = urllib.request.Request(
    'https://agent-utilities.agent-utilities.workers.dev/v1/content/index',
    headers={'Accept': 'application/json', 'User-Agent': 'MyShoppingAgent/1.0'},
)
with urllib.request.urlopen(request, timeout=15) as response:
    catalog = json.load(response)
```

Browser clients can use their normal browser headers. If an identified client still receives an edge error, stop and report the status through the support contact in /policies. [Cloudflare describes error 1010](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1010/) as a browser-signature restriction; changing payment credentials will not resolve it.

## Discover

GET /v1/tools returns descriptions, schemas, prices and example requests.
GET /v1/tools?category=commerce filters the catalog.
GET /openapi.json returns the API contract.
POST /mcp supports tool discovery and calls using the same payment headers.

## Card-funded service credits

Open /billing and check the displayed mode:

1. Create an API key for the active mode and save it privately. The server stores a hash, not the key. New accounts include a separate recovery key; save both credentials.
2. Open the $5 Checkout to buy credits for useful work. Live mode charges real USD; sandbox mode accepts Stripe test details only. Do not make seller-funded live purchases just to test.
3. Return to /billing and paste your saved key. Check your balance. A browser redirect is not payment confirmation; only a verified Stripe webhook grants credits.
4. Supply Authorization: Bearer <your key> and Idempotency-Key: <current Unix milliseconds>_<random UUID> on each tool call.

For example, the JSON body for POST /v1/tools/commerce.gtin-validate is:

    {"code":"036000291452"}

Generate a request ID once for a logical operation, and keep that ID, URL and JSON body unchanged for retries. A successful credit response contains result, a receipt with chargedMicroUsd, and recoveryExpiresAt. 1 dollar of service credits = 1,000,000 micro-dollar units. The same numeric tool price applies to either credit mode or test-USDC mode.

A $5 pack contains 5,000,000 service micro-dollars. It covers 10,000 calls at 500 units each, or a different number for a mix of tools. Credits are usable only with this service and cannot be transferred or withdrawn. Sandbox credits have no monetary value.

GET /billing/api/balance requires the same Bearer key. POST /billing/api/checkout requires a separate stable UUID Idempotency-Key. After a checkout timeout, retry that ID instead of making a new purchase. Check your balance before creating another checkout after the 23-hour checkout retry window.

## Set a maximum price

For prepaid credits, send `X-Max-Credit-Micro-Usd: 300` to authorize at most $0.0003 for a new tool call. Read `creditPriceLimits: true` from `/billing/api/status` before relying on this feature. It works on both `POST /v1/tools/<id>` and MCP `tools/call` HTTP requests. Use a nonnegative integer with no leading zeros, at most 999999999999; malformed values return 400. The header requires API-key credits and does not apply to crypto.

The ledger returns HTTP 412 with `price_limit_exceeded` if the current price exceeds your ceiling, before creating a reservation, deducting credits or using daily call capacity. Omit the header to use existing behavior. Never automatically raise a rejected ceiling; review the price first.

Keep the same ID, tool, body and ceiling after a lost response. A matching completed or pending reservation can be recovered with a zero ceiling because it creates no new reservation. Zero does not cancel or refund a charge already authorized. Recovery still requires the same tool version, price and input and is subject to the ten-minute window.

The browser workspace caps each new call at its displayed catalog price. The runnable cart recipe caps its three logical calls at their discovered prices, totaling at most 1300 micro-dollars. MCP adapter 0.3.0 caps each new debit at its startup catalog price; its recovery helper uses a zero ceiling and cannot create a new reservation. It has no total session budget. Older adapter 0.2.1 does not set a ceiling. An API client can set per-call ceilings itself.

## Recovery and limits

- Tool results are encrypted and recoverable for ten minutes. The cleanup alarm removes expired result material; cleanup may be delayed by runtime scheduling.
- An unfinished reservation is refunded after its recovery deadline. Failed tools are not charged. A restart can rerun an unfinished read-only tool before committing its result.
- Request tombstones last one day; old timestamped request IDs cannot create a new debit after cleanup.
- No automatic top-ups. No subscription or recurring charge. Refund/dispute events freeze the account for operator review.
- Preview limits: 100 account creations per day, 20 lifetime checkout attempts per account and 1,000 new credit tool calls per day across the service.
- API key loss can be recovered with the separately saved recovery credential. If both are lost, self-service recovery is unavailable. Account/purchase/credit records persist for reconciliation. See /policies for account and retention information.
- Never put keys in URLs, source code, screenshots, logs or shared documents. There is no public free-execution bypass.

## Optional crypto test

Open /wallet-test in the browser with MetaMask installed. Select Base Sepolia (84532). This requires test USDC in Circle Gateway and Base Sepolia ETH for the initial approval/deposit. The page can request exactly 1 test-USDC approval and deposit through your wallet; you review and approve transactions yourself.

Payment execution stays unavailable until the operator enables the configured testnet service. A test call requests 0.0003 test USDC for GTIN validation. It uses two signatures: the official Circle payment authorization, followed by an input-binding signature. Retry the identical prepared request after response loss or uncertain settlement. Keep the page open until the outcome is known; signed authorizations are held only in tab memory and are lost on reload.

An ordinary x402 client needs our request-binding adapter. The included src/client.ts supports both local signing accounts and browser-wallet signers. The service never needs your wallet's private key.

## Current launch status

Check /health and /billing/api/status for the deployed flags. A configured test mode is not proof of successful provider payments, profitability or a paying customer. Stripe sandbox checkout, webhook crediting, request retry, duplicate webhook delivery, and refund freeze were verified on September 17, 2026. Live-mode code and credential recovery are implemented. Live provider credentials and deployed mode are configured; a genuine live customer purchase and fulfillment remain unverified. Fixture tests do not prove customer demand.

## Replace an API key

In /billing, enter your current key, expand Replace API key, generate a replacement, copy it to private storage and confirm you saved it. Activate the replacement, then update your agents. The old key stops working immediately. Your balance, account ID, checkout history and retry IDs remain the same. Existing pending tool retries in the tab automatically use the new key.

For API clients, generate 32 cryptographically random bytes, encode them as 64 lowercase hexadecimal characters and prepend au_live_ for live mode or au_test_ for sandbox. Save that replacement before sending POST /billing/api/accounts/rotate-key with Authorization: Bearer <current-key>, Content-Type: application/json, and JSON containing only replacementKey. The server stores hashes only. Do not place either key in URLs, logs, shell history or source files.

If the response is lost, repeat with the same replacement. If the old credential no longer works, authenticate that same request with the saved replacement itself: alreadyActive confirms it is active without rotating again. Do not generate another replacement until you resolve the outcome. Rotation cannot bypass frozen-account restrictions and is capped at 100 changes per account. Losing both the API and recovery credentials prevents automatic recovery.

## Live versus test mode

Read /billing/api/status before using the service. Live keys start au_live_ and create real $5 USD Stripe checkouts; test keys start au_test_ and cannot access live balances. Keep recovery credentials (au_recovery_live_ or au_recovery_test_) separate from your agent. The public workspace accepts only its currently configured mode. Crypto remains a separate testnet-only feature. /policies lists support, refunds, privacy and release limits.

## Recover a lost API key

Use Recover an account in /billing. Enter the saved recovery credential, prepare replacement credentials, copy and save both replacements, then activate recovery. The service revokes the previous API key and recovery credential atomically while preserving your account ID, balance, purchases, retry records and any account freeze.

API clients can POST /billing/api/accounts/recover using Authorization: Bearer <recovery-key> and JSON with replacementKey and replacementRecoveryKey. Each new credential uses 32 cryptographically random bytes encoded as 64 lowercase hexadecimal characters, prefixed for its type and mode. Persist both replacements privately before sending the request. After response loss, retry the same pair; if the old recovery credential is revoked, repeat with the new recovery credential. alreadyActive confirms success. Do not create a new pair to retry an uncertain recovery.


---

# Agent Utilities MCP

Connect a local stdio MCP client to 36 paid utility APIs for HTML extraction, JSON validation, agent configuration checks and product data. This MIT-licensed adapter runs locally; the hosted API is a paid service.

[Tool catalog](https://agent-utilities.agent-utilities.workers.dev/tools) · [Installation guide](https://agent-utilities.agent-utilities.workers.dev/integrations/mcp) · [Pricing](https://agent-utilities.agent-utilities.workers.dev/pricing) · [Policies and support](https://agent-utilities.agent-utilities.workers.dev/policies)

VS Code users: [open the setup link and private-key configuration](https://agent-utilities.agent-utilities.workers.dev/integrations/mcp#vscode). [Detailed instructions](https://github.com/cgvhbjk/agent-utilities-mcp/blob/main/VSCODE.md) are included in this source repository.

## Try the shopping example without an account

Clone this repository and preview the supplied cart with Node.js 22+:

```sh
cd examples/cart
shasum -a 256 -c cart-workflow.mjs.sha256
node cart-workflow.mjs --preview cart-example.json
```

Preview validates the input and prints the three-step plan **offline**, with no API key, network request or charge. It does not execute the tools. The included [expected output](https://github.com/cgvhbjk/agent-utilities-mcp/blob/main/examples/cart/cart-example-output.json) is a local fixture: German price strings become decimal amounts, guarded patches update the supplied cart snapshot, and cost reconciliation returns a known total of **€45.92**. Tax is unknown, so the final total remains `null`.

To run those three operations against the hosted service, privately set `AGENT_UTILITIES_API_KEY` in your process environment and explicitly choose:

```sh
node cart-workflow.mjs --execute cart-example.json
```

Execution spends existing service credits. The recipe enforces per-call price ceilings totaling **at most $0.0013** (0.13 cents) across its three logical calls. It stops if a discovered price is too high or a later price exceeds the authorized ceiling. Completed steps stay charged if a later step fails. Each step returns its debit receipt and recovery information; do not rerun the entire recipe after an uncertain response. Read the [recipe instructions](https://github.com/cgvhbjk/agent-utilities-mcp/blob/main/examples/cart/CART-WORKFLOW-README.md) before execution. This example does not buy credits or place a merchant order.

The recipe is a separate standalone download, not part of the immutable v0.3.0 MCPB bundle. You can also get it from the [workflow page](https://agent-utilities.agent-utilities.workers.dev/use-cases/normalize-prices-update-cart). The generic MCP adapter's spending behavior remains as described below.

## Read the material directly from an agent

No account or key is needed to read contracts, examples, prices and guides:

```sh
curl --fail --silent --show-error \
  https://agent-utilities.agent-utilities.workers.dev/v1/content/index
```

- [Complete JSON content](https://agent-utilities.agent-utilities.workers.dev/v1/content): tool input/output schemas, example requests, execution headers, workflows and documentation.
- [Full text guide](https://agent-utilities.agent-utilities.workers.dev/llms-full.txt): the same material as plain text.
- [One tool's contract](https://agent-utilities.agent-utilities.workers.dev/v1/content/tools/commerce.money-parse): request schema, example, price and execution URL.
- [Cart workflow](https://agent-utilities.agent-utilities.workers.dev/v1/content/workflows/normalize-prices-update-cart): the steps and current aggregate price.
- [OpenAPI](https://agent-utilities.agent-utilities.workers.dev/openapi.json): HTTP tool operations, optional credit ceiling header and error responses.

These public GET endpoints support cross-origin browser reads. Tool execution remains paid. Custom HTTP clients can send `X-Max-Credit-Micro-Usd` to cap a new prepaid credit debit; read the [quickstart](https://agent-utilities.agent-utilities.workers.dev/quickstart) for retry semantics. Adapter 0.3.0 caps each new call at its startup catalog price and requires server-advertised support.

## Prefer Python?

The [Python HTTP client](https://agent-utilities.agent-utilities.workers.dev/integrations/python) uses only Python 3.10+ standard libraries. See [examples/python](https://github.com/cgvhbjk/agent-utilities-mcp/tree/main/examples/python) for offline preview, free discovery and explicit paid calls with per-call ceilings and stable retry identities. No Node or MCP process is required for this route. It is separate from the MCPB bundle.

## Install

Also listed on [Smithery](https://smithery.ai/servers/benjaminhelfand/agent-utilities) as a local Node.js MCPB bundle. Its download matches the v0.3.0 GitHub artifact. Connect the adapter for the complete current tool schemas and prices; directory metadata is a discovery summary.

For clients that support MCP bundles, download `agent-utilities-mcp-0.3.0.mcpb` and its checksum from the [v0.3.0 release](https://github.com/cgvhbjk/agent-utilities-mcp/releases/tag/v0.3.0). Verify the checksum before importing the bundle through your client's extension settings. It contains the adapter, manifest and license notices. The bundle is unsigned; the release checksum establishes file consistency, not an independent signature. Bundle schema and standalone execution are tested; installation in each desktop client is not verified.

The bundle's optional **Agent Utilities API key** setting is marked sensitive. Leave it empty for free discovery, or enter only your API key to enable paid calls. Node.js 22+ is required; use a compatible runtime provided by your client or installed locally. If your client cannot import MCPB files, use the manual setup below.

Requires Node.js 22 or newer. Download `agent-utilities-mcp.mjs` and its `.sha256` file from the installation guide, then verify the file from its folder:

```sh
shasum -a 256 -c agent-utilities-mcp.mjs.sha256
```

Alternatively, clone this repository and use its bundled `agent-utilities-mcp.mjs` directly. No npm install is needed to run the bundle. Source is in `src/`; `npm ci && npm run build` rebuilds it. The public bundle is tested as a standalone process outside the application's dependency tree.

For a client that uses the common `mcpServers` configuration format:

```json
{
  "mcpServers": {
    "agent-utilities": {
      "command": "node",
      "args": ["/absolute/path/agent-utilities-mcp.mjs"],
      "env": {
        "AGENT_UTILITIES_API_KEY": "YOUR_PRIVATE_API_KEY"
      }
    }
  }
}
```

Replace the file path. Configure the API key privately using the client's secret settings where supported; never commit a real key or paste it into an agent prompt. Use the absolute path to Node if the client cannot find it. Remote-only MCP clients cannot launch this stdio adapter.

Omit the key to discover tools without spending credits. Obtain an API key and separately saved recovery key in the [workspace](https://agent-utilities.agent-utilities.workers.dev/billing). Only give the API key to the adapter. Live mode sells $5 USD prepaid service credits. Check the displayed mode before buying.

## What it does

- Fetches the public tool definitions and current per-call prices on startup.
- Exposes the 36 service tools and one recovery helper. The recovery helper is not an additional product.
- Sends authenticated calls only to the fixed Agent Utilities origin; redirects are rejected.
- Generates a stable debit request ID and retries one failed HTTP exchange with the identical body and ID.
- Keeps request identities and input hashes in process memory, without logging inputs, results or credentials. Remote data handling is described in the service policies.
- Does not purchase credits, automatically top up, access a wallet or accept recovery credentials.

Try a useful task such as: “Use commerce_gtin_validate to check barcode 036000291452.” One successful call costs $0.0003. Current tool prices range from $0.0003 to $0.002; these are experimental prices, not fixed forever. Every new operation spends credits. Version 0.3.0 caps each new debit at the price discovered at startup. There is no total session budget; repeated new calls can spend the available balance. A higher server price returns HTTP 412 instead of increasing the ceiling. Restart only after reviewing refreshed prices. Review prices and approve spending in your client.

## Retry an uncertain result

Results and uncertain outcomes include a `requestId`. Call `agent_utilities_retry` with that ID, the original MCP tool name, and the original arguments:

```json
{
  "requestId": "COPY_THE_RETURNED_REQUEST_ID",
  "name": "commerce_gtin_validate",
  "arguments": { "code": "036000291452" }
}
```

Within ten minutes a completed request returns the saved result without another debit. In version 0.3.0 the recovery helper sends a zero ceiling: a request that never reached the service is rejected without a new reservation. This does not cancel a previous reservation or refund a charge. The automatic transport retry of a new call retains its original nonzero ceiling and can still execute that authorized operation once. Do not generate a new ID or change the input to recover an uncertain result. Expired request identities cannot make another debit. Reusing an MCP request ID within one process also retains its original debit identity.

After a process restart you need the returned request ID and original input for recovery. If the process died before your client received the ID, inspect the balance or contact support before repeating the operation. No durable local input or result history is stored. Each process retains up to 5,000 MCP request identities, then refuses new calls until restarted; finish pending recovery first.

## Service limits

The release allows 1,000 new paid calls per day across the service. Inputs are bounded to 128 KiB including protocol overhead. Network tools are restricted to the hosts shown in the catalog; they are not a general web browser. Security checks are heuristics. Successful results are encrypted for ten-minute retry recovery, with request tombstones retained for one day. See the policies for retention and refund details.

Automated tests verify lost-response recovery against a local Cloudflare credit ledger. They do not establish customer demand or prove a live customer purchase. Directory validation and free tool discovery are not sales.

## License

Adapter code: MIT. Bundled dependencies: see `THIRD-PARTY-NOTICES.txt`. The license covers the adapter, not free access to the hosted APIs.


## Choose whole packs for a shopping task

The [pack planner](https://agent-utilities.agent-utilities.workers.dev/tools/commerce.pack-plan) finds the minimum item subtotal for a required count of interchangeable items using explicit pack limits. Twelve items can cost $15.98 as two six-packs at $7.99, even when a ten-pack at $11.99 has a lower unit price. The operation costs $0.0008 in prepaid credits. Shipping, tax, coupons and product equivalence are outside its optimization.

Call `commerce_pack_plan` through MCP, or use the [Python client](https://agent-utilities.agent-utilities.workers.dev/integrations/python) with tool ID `commerce.pack-plan` and an explicit 800-micro-dollar ceiling. Inspect the [free JSON contract](https://agent-utilities.agent-utilities.workers.dev/v1/content/tools/commerce.pack-plan) before executing. The [worked workflow](https://agent-utilities.agent-utilities.workers.dev/use-cases/choose-whole-packs) explains stock limits and how pack counts map into cart reconciliation. The adapter discovers this tool from the service; new tools do not require replacing the adapter.

Try the [Python pack-planning example](examples/python/pack_plan_example.py) with its [three sample cases](examples/python/pack_plan_cases.json). Run `python3 pack_plan_example.py` from `examples/python`, or select `--scenario limited-stock` / `--scenario insufficient-stock`. The default is an offline display of fixed fixtures; it sends no request and computes no new answer. Adding `--execute` explicitly authorizes one hosted call capped at $0.0008 using existing credits. A valid infeasible result is billable too. See the [Python guide](https://agent-utilities.agent-utilities.workers.dev/integrations/python) for checksums, input limits and recovery before executing. Each new run creates a new ID; do not rerun to recover an uncertain paid result.

## Upgrading from 0.2.1

Install 0.3.0 for per-call price ceilings and recovery-only manual retries. Version 0.2.1 does not enforce these adapter protections. Existing 0.2.1 release bytes remain available and unchanged; upgrading requires replacing the installed adapter. The per-call ceiling does not limit the number of new calls or provide a total session budget.

### Compare delivered checkout totals

The standard-library Python recipe in `examples/python/compare_carts.py` compares supplied merchant checkout snapshots using one capped reconciliation per cart. Default preview is offline; execution requires `--execute` and existing credits. It ranks complete totals, retains ties and declines to name an overall winner when any cart has unknown shipping, tax or fees. The two-cart default ceiling is $0.001. See the [comparison guide](https://agent-utilities.agent-utilities.workers.dev/integrations/python#compare-carts) for sample inputs, checksums, explicit budgets and recovery.


---

# Runnable cart cleanup recipe

Download the Node.js 22+ recipe, its checksum and sample JSON from [the workflow page](https://agent-utilities.agent-utilities.workers.dev/use-cases/normalize-prices-update-cart). No npm install is required. The script includes the existing Agent Utilities MCP adapter and SDK.

From the download folder:

```sh
shasum -a 256 -c cart-workflow.mjs.sha256
node cart-workflow.mjs --preview cart-example.json
```

Preview validates and prints your input and planned steps locally. It does not contact the service, use a key or calculate the final result. Running without arguments previews the included sample. The checksum is served alongside the file and establishes consistency, not an independent signature.

The sample replaces €17.00 coffee with €16.49 and a €10.00 mug with €9.95. Its two coffee bags, one mug, €2 order discount and €4.99 shipping produce a known total of €45.92. Unknown tax keeps the final total null. `cart-example-output.json` is generated from the actual tool implementations at build time, without network requests or payments; it is an expected fixture, not a live receipt.

## Execute with prepaid credits

Obtain an API key and existing prepaid balance in the [workspace](https://agent-utilities.agent-utilities.workers.dev/billing). Set `AGENT_UTILITIES_API_KEY` privately using your environment or secret manager. Never enter a recovery credential, put a key in a command argument or commit one to a file.

```sh
node cart-workflow.mjs --execute cart-example.json
```

This explicit command authorizes up to three separately billed operations: `commerce.money-parse`, `data.json-patch`, and `commerce.price-components`. Current total estimate: 1,300 micro-dollars, or $0.0013. The recipe checks public prices and key mode before starting, and refuses to start if the estimate has risen above 1,300. It requires server-enforced credit price limits and caps each call at its discovered price using X-Max-Credit-Micro-Usd. These three calls together cannot debit more than 1,300 micro-dollars. If a price rises after discovery, the service rejects that new reservation with HTTP 412 and no debit; the recipe stops without increasing the cap. Receipts contain actual debits. It never purchases credits, tops up or places a merchant order.

Results are newline-delimited JSON. `execution-start` shows the mode, discovered prices and maxTotalMicroUsd ceiling. Each `step-result` contains the exact request arguments, result, debit receipt and retry information. `workflow-complete` combines the normalized amounts, updated supplied snapshot and reconciliation. Keep output private because it contains your supplied cart data. If saving it, use a private directory and restrictive file permissions.

Completed calls remain charged if a later step fails. If a displayed price is invalid, parsing is still a successful billed check; the recipe stops before patching. Known missing tax, shipping or fees remain null and do not become zero.

## Recover a partial run

The existing MCP adapter automatically retries one uncertain HTTP exchange using the same debit identity. It does not retry the whole recipe. If a step still fails or is uncertain, execution stops and prints that step's result and original arguments.

Use `agent_utilities_retry` in your configured MCP client with the returned `requestId`, original MCP tool name and exact original arguments within ten minutes. Follow the [adapter recovery instructions](https://agent-utilities.agent-utilities.workers.dev/integrations/mcp). Do not rerun `--execute` to recover: a new run generates new operations and can charge again for completed steps. The recipe does not automatically resume later steps; use the recovered output and documented mapping to continue in your MCP client.

There is no durable local journal. If the process exits before returning an ID, inspect your balance or contact support before repeating that operation. The script does not modify your input file or a merchant cart.

## Bring your own cart

Use the exact shape of `cart-example.json`:

- Declare one supported locale, currency and decimal scale. The caller establishes those facts; symbols alone do not prove currency.
- Supply 1–100 items with unique IDs and nonnegative exact decimal strings. Quantities are integers. Every cost is explicit; use null for unknown shipping, tax or fees.
- Supply 1–24 displayed prices. Each price ID must identify an existing item. Unlisted items keep their original price.
- The patch tests currency, scale, item ID and original unit price before each replacement. It applies to the supplied snapshot only.
- Input files are limited to 32 KiB. Unsupported fields and excessive decimal precision fail before paid calls.

The downloadable client code is MIT-licensed; bundled dependency licenses are in `CART-WORKFLOW-NOTICES.txt`. The hosted tools remain paid APIs. Local tests and fixture output do not establish a customer sale.


---

# Buy enough units without choosing the wrong pack mix

The lowest price per unit is not always the cheapest way to buy a requested quantity. For twelve identical items, two six-packs at $7.99 each cost less than two ten-packs at $11.99 each, even though the ten-pack has the lower unit price. First establish that the items are interchangeable; these tools do not verify compatibility.

1. See the unit-price tradeoff
Tool: commerce.unit-price
Compare each offer using unit each, quantity equal to the number of units in one pack, and the whole-pack price. A six-pack at $7.99 costs about $1.331667 per item; a ten-pack at $11.99 costs $1.199. This comparison alone does not choose how many packs to buy.

2. Choose an exact whole-pack combination
Tool: commerce.pack-plan
Set requiredUnits to 12, supply those pack sizes and prices, and set maxPacks to the actual limit you know for each offer. With ten packs available for each, the minimum item subtotal is $15.98: two six-packs, twelve items and no excess. Two ten-packs would cost $23.98. Prices tie-break by least excess, then fewest packs. Unknown stock is not unlimited; obtain a usable limit before planning.

3. Include the remaining checkout costs
Tool: commerce.price-components
For each selected plan line, map its original offer price to unitPrice and its packs count to quantity; quantity here counts packs, not individual units. Supply explicit discounts and shipping, tax and fees. Keep unknown components null. The $15.98 item subtotal is not a verified delivered total.

A minimum item-cost basket within supplied pack limits, plus a separate reconciliation of known checkout costs. Use interchangeable units in one currency. Shipping thresholds, coupons and cross-merchant costs can change the best delivered basket and are outside this planner. No merchant inventory is reserved and no order is placed.

---

# Normalize displayed prices and update a cart snapshot

Displayed prices may use different decimal separators, and an agent can overwrite the wrong cart entry if it applies an unguarded change. Normalize prices first, then test the expected record before editing its snapshot.

1. Read the price with its declared format
Tool: commerce.money-parse
Supply a supported locale, currency and decimal scale. For example, 1.234,56 € with de-DE, EUR and two decimal places becomes 1234.56. Check each returned valid flag; ranges, prose, conflicting currency tokens and excess precision remain errors. A shared $ symbol does not establish which dollar currency the merchant uses.

2. Guard changes to the supplied snapshot
Tool: data.json-patch
Use a test operation on the expected SKU or currency before replacing a price or quantity. Map only a valid normalized amount into the patch value. Array additions insert at an index; /- appends. If any operation fails, no result is committed and the original supplied snapshot is unchanged. This tool does not write to a merchant cart or place an order.

3. Recalculate explicit components
Tool: commerce.price-components
Map the updated snapshot into the item schema, including unitPrice, quantity and discount. Supply the same declared currency and decimal scale. Keep unavailable shipping, tax and fees as null. A known subtotal is not a complete checkout total until every component is supplied.

Normalized price strings, a guarded JSON snapshot and an exact reconciliation. Each operation is a separate call; currency selection, product identity and permission to modify a real cart remain the caller's responsibility.

---

# Check product data before your agent decides

A product page can describe several sizes, colors and offers. Your agent needs to distinguish the item it wants from the item a merchant actually offers.

1. Extract the declared product offers
Tool: commerce.offer-extract
Pass the HTML your agent already obtained. Product offers retain source pointers, currency, price and availability when supplied. Missing prices, aggregate ranges and ambiguous price specifications remain explicit. Extraction does not establish that a listing is accurate.

2. Check the retail identifier
Tool: commerce.gtin-validate
Validate the check digit before comparing identifiers across listings. A valid GTIN is a structural check, not proof that the item exists or that a seller is trustworthy.

3. Compare the actual variant
Tool: commerce.variant-compare
Supply the requested and offered attributes explicitly. The result separates missing fields from mismatches, so a blue medium shirt is not silently replaced with a large one.

A structured set of facts and mismatches that your agent can use in its decision. These tools do not place orders or determine merchant trustworthiness.

---

# Compare pack prices without hiding missing costs

A larger pack can have a lower unit price but a higher checkout total. Give your agent separate answers for the product offer, the price per unit, and the costs that are still unknown.

1. Keep the price attached to its source
Tool: commerce.offer-extract
Extract each supplied product page. Use an individual Offer price and currency, retaining its source pointer. Do not replace an individual price with an AggregateOffer lowPrice or choose a conditional member price without checking eligibility.

2. Compare the same quantity
Tool: commerce.unit-price
Map each individual offer price to the price field. Supply verified packCount, quantity and unit explicitly; package size is not inferred from a product title. For example, $8.99 for 500 g is $1.798 per 100 g, while $16.49 for 1 kg is $1.649 per 100 g. All prices must be in the same declared currency.

3. Reconcile what the cart actually includes
Tool: commerce.price-components
Pass the selected whole-pack price as unitPrice, plus item count and explicit line and order discounts. Declare the currency decimal places and provide shipping, tax and fees as amounts or null when unknown. The example with two $16.49 bags, a $2 discount and $4.99 shipping has a known total of $35.97; unknown tax keeps the final total null.

An exact unit-price comparison and a separately reconciled cart. The lowest unit price is not a recommendation about product quality or final delivered cost. These tools never place orders, convert currencies or calculate tax from local law.

---

# Turn supplied HTML into structured research inputs

Navigation, repeated links and formatting make raw HTML awkward to use in a research workflow. Keep extraction separate from interpretation and preserve the source context.

1. Keep the page context
Tool: html.metadata
Extract the title, description, declared canonical URL and language. Supply the source URL to resolve relative links. Declared metadata can be incorrect; keep your original source URL too.

2. Extract readable content
Tool: html.main-text
Send the same supplied HTML to obtain article text and the extraction method. This parses HTML; it does not execute JavaScript or render content that is absent from the document.

3. Keep bounded snippets and offsets
Tool: text.chunk
Split extracted text into overlapping chunks. Offsets use UTF-16 units, and surrogate pairs remain intact. This is character-based chunking, not a model-specific token count.

Readable, bounded chunks alongside source metadata, ready for your own retrieval or summarization workflow. The agent supplies the HTML it is authorized to access.

---

# Catch configuration mistakes before a run

Missing environment variables and confusing tool names can break an otherwise working agent. Check these deterministic details before starting a long run.

1. Compare environment-variable names
Tool: agents.env-template-check
Supply a template and configuration to find missing, extra and duplicate variable names. Values are not returned. Prefer sanitized assignments when checking names; real credentials are unnecessary.

2. Find ambiguous tool names
Tool: agents.tool-name-conflicts
Check a combined tool catalog for duplicate names and collisions after Unicode, case and separator normalization. A conflict is a prompt to review naming, not proof of a client failure.

3. Review explicit risk indicators
Tool: agents.config-audit
Apply five fixed heuristics to configuration text. Findings identify matched language for review. They cannot certify that an agent is safe or enforce its permissions.

A short list of concrete configuration issues to review before execution. Keep permission enforcement and credential storage in your own runtime.

---

# html.main-text

Extract article text from supplied HTML.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.main-text

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "title": {
      "type": "string"
    },
    "text": {
      "type": "string"
    },
    "method": {
      "type": "string"
    }
  },
  "required": [
    "title",
    "text",
    "method"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<html><head><title>Field notes</title></head><body><article><h1>Field notes</h1><p>Agents need predictable, bounded tools with clear prices and useful outputs.</p></article></body></html>"
}
```

---

# html.jsonld

Parse up to 50 JSON-LD blocks from supplied HTML.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.jsonld

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "items": {}
    },
    "invalidBlocks": {
      "type": "number"
    }
  },
  "required": [
    "items",
    "invalidBlocks"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<script type=\"application/ld+json\">{\"@type\":\"Product\",\"name\":\"Cup\"}</script>"
}
```

---

# html.tables

Extract source table cells without expanding spans.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.tables

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "tables": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "caption": {
            "type": "string"
          },
          "rows": {
            "type": "array",
            "items": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          },
          "hasSpans": {
            "type": "boolean"
          }
        },
        "required": [
          "caption",
          "rows",
          "hasSpans"
        ],
        "additionalProperties": false
      }
    },
    "spanPolicy": {
      "type": "string"
    }
  },
  "required": [
    "tables",
    "spanPolicy"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<table><tr><th>Item</th></tr><tr><td>Cup</td></tr></table>"
}
```

---

# web.readable-fetch

Fetch readable text from an approved public HTTPS host.

Price: 2000 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/web.readable-fetch

Input schema:
```json
{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "maxLength": 2048
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "status": {
      "type": "number"
    },
    "title": {
      "type": "string"
    },
    "text": {
      "type": "string"
    },
    "method": {
      "type": "string"
    }
  },
  "required": [
    "url",
    "status",
    "title",
    "text",
    "method"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "url": "https://example.com/"
}
```

---

# web.redirect-trace

Trace up to four redirects across approved public HTTPS hosts.

Price: 1000 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/web.redirect-trace

Input schema:
```json
{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "maxLength": 2048
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "status": {
      "type": "number"
    },
    "redirects": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "url": {
            "type": "string"
          },
          "status": {
            "type": "number"
          }
        },
        "required": [
          "url",
          "status"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "url",
    "status",
    "redirects"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "url": "https://example.com/"
}
```

---

# web.robots-evaluate

Evaluate supplied robots.txt for a URL and user agent; no network fetch.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/web.robots-evaluate

Input schema:
```json
{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "maxLength": 2048
    },
    "robots": {
      "type": "string",
      "maxLength": 100000
    },
    "userAgent": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200
    }
  },
  "required": [
    "url",
    "robots",
    "userAgent"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "allowed": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "crawlDelay": {
      "type": [
        "number",
        "null"
      ]
    },
    "sitemaps": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "allowed",
    "crawlDelay",
    "sitemaps",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "url": "https://example.com/private",
  "robots": "User-agent: *\nDisallow: /private",
  "userAgent": "ExampleBot"
}
```

---

# contracts.openapi-lint

Validate OpenAPI 3.0 JSON structure and internal references.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/contracts.openapi-lint

Input schema:
```json
{
  "type": "object",
  "properties": {
    "document": {
      "type": "object"
    }
  },
  "required": [
    "document"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "valid": {
      "type": "boolean"
    },
    "issues": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "rule": {
            "type": "string"
          }
        },
        "required": [
          "path",
          "rule"
        ],
        "additionalProperties": false
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "valid",
    "issues",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "document": {
    "openapi": "3.0.3",
    "info": {
      "title": "Demo",
      "version": "1"
    },
    "paths": {
      "/hello": {
        "get": {
          "responses": {
            "200": {
              "description": "OK"
            }
          }
        }
      }
    }
  }
}
```

---

# contracts.openapi-diff

Detect selected direct breaking changes between OpenAPI 3.0 documents.

Price: 800 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/contracts.openapi-diff

Input schema:
```json
{
  "type": "object",
  "properties": {
    "before": {
      "type": "object"
    },
    "after": {
      "type": "object"
    }
  },
  "required": [
    "before",
    "after"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "changes": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          }
        },
        "required": [
          "path",
          "kind"
        ],
        "additionalProperties": false
      }
    },
    "breakingChangesDetected": {
      "type": "boolean"
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "changes",
    "breakingChangesDetected",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "before": {
    "openapi": "3.0.3",
    "info": {
      "title": "Demo",
      "version": "1"
    },
    "paths": {
      "/hello": {
        "get": {
          "responses": {
            "200": {
              "description": "OK"
            }
          }
        }
      }
    }
  },
  "after": {
    "openapi": "3.0.3",
    "info": {
      "title": "Demo",
      "version": "1"
    },
    "paths": {}
  }
}
```

---

# contracts.jsonschema-validate

Validate data using a bounded JSON Schema 2020-12 subset.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/contracts.jsonschema-validate

Input schema:
```json
{
  "type": "object",
  "properties": {
    "schema": {
      "type": [
        "object",
        "boolean"
      ]
    },
    "data": {}
  },
  "required": [
    "schema",
    "data"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "valid": {
      "type": "boolean"
    },
    "issues": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "rule": {
            "type": "string"
          }
        },
        "required": [
          "path",
          "rule"
        ],
        "additionalProperties": false
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "valid",
    "issues",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "schema": {
    "type": "integer",
    "minimum": 1
  },
  "data": 3
}
```

---

# security.secret-scan

Detect five families of credential patterns with fully masked findings.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/security.secret-scan

Input schema:
```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 100000
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "findings": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "rule": {
            "type": "string"
          },
          "start": {
            "type": "number"
          },
          "end": {
            "type": "number"
          },
          "line": {
            "type": "number"
          },
          "masked": {
            "type": "string"
          }
        },
        "required": [
          "rule",
          "start",
          "end",
          "line",
          "masked"
        ],
        "additionalProperties": false
      }
    },
    "rulesVersion": {
      "type": "string"
    },
    "limitReached": {
      "type": "boolean"
    },
    "caveat": {
      "type": "string"
    }
  },
  "required": [
    "findings",
    "rulesVersion",
    "limitReached",
    "caveat"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "text": "No credentials in this example."
}
```

---

# security.secret-redact

Replace detected credential patterns with redaction markers.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/security.secret-redact

Input schema:
```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 100000
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "findings": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "rule": {
            "type": "string"
          },
          "start": {
            "type": "number"
          },
          "end": {
            "type": "number"
          },
          "line": {
            "type": "number"
          },
          "masked": {
            "type": "string"
          }
        },
        "required": [
          "rule",
          "start",
          "end",
          "line",
          "masked"
        ],
        "additionalProperties": false
      }
    },
    "rulesVersion": {
      "type": "string"
    },
    "limitReached": {
      "type": "boolean"
    },
    "caveat": {
      "type": "string"
    },
    "text": {
      "type": "string"
    }
  },
  "required": [
    "findings",
    "rulesVersion",
    "limitReached",
    "caveat",
    "text"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "text": "No credentials in this example."
}
```

---

# agents.config-audit

Review agent configuration text with five fixed risk heuristics.

Price: 800 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/agents.config-audit

Input schema:
```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 100000
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "findings": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "rule": {
            "type": "string"
          },
          "severity": {
            "type": "string"
          },
          "message": {
            "type": "string"
          }
        },
        "required": [
          "rule",
          "severity",
          "message"
        ],
        "additionalProperties": false
      }
    },
    "rulesVersion": {
      "type": "string"
    },
    "caveat": {
      "type": "string"
    }
  },
  "required": [
    "findings",
    "rulesVersion",
    "caveat"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "text": "Require approval before shell execution. Spending budget: $1."
}
```

---

# data.json-patch

Apply up to 100 RFC 6902 operations transactionally to supplied JSON, with strict pointers, safe object properties and bounded intermediate results.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/data.json-patch

Input schema:
```json
{
  "type": "object",
  "properties": {
    "data": {},
    "patch": {
      "type": "array",
      "items": {
        "oneOf": [
          {
            "type": "object",
            "properties": {
              "op": {
                "const": "add"
              },
              "path": {
                "type": "string",
                "maxLength": 2048
              },
              "value": {}
            },
            "required": [
              "op",
              "path",
              "value"
            ]
          },
          {
            "type": "object",
            "properties": {
              "op": {
                "const": "replace"
              },
              "path": {
                "type": "string",
                "maxLength": 2048
              },
              "value": {}
            },
            "required": [
              "op",
              "path",
              "value"
            ]
          },
          {
            "type": "object",
            "properties": {
              "op": {
                "const": "test"
              },
              "path": {
                "type": "string",
                "maxLength": 2048
              },
              "value": {}
            },
            "required": [
              "op",
              "path",
              "value"
            ]
          },
          {
            "type": "object",
            "properties": {
              "op": {
                "const": "remove"
              },
              "path": {
                "type": "string",
                "maxLength": 2048
              }
            },
            "required": [
              "op",
              "path"
            ]
          },
          {
            "type": "object",
            "properties": {
              "op": {
                "const": "move"
              },
              "path": {
                "type": "string",
                "maxLength": 2048
              },
              "from": {
                "type": "string",
                "maxLength": 2048
              }
            },
            "required": [
              "op",
              "path",
              "from"
            ]
          },
          {
            "type": "object",
            "properties": {
              "op": {
                "const": "copy"
              },
              "path": {
                "type": "string",
                "maxLength": 2048
              },
              "from": {
                "type": "string",
                "maxLength": 2048
              }
            },
            "required": [
              "op",
              "path",
              "from"
            ]
          }
        ]
      },
      "maxItems": 100
    }
  },
  "required": [
    "data",
    "patch"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "documentExists": {
      "type": "boolean"
    },
    "data": {},
    "operationsApplied": {
      "type": "number"
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "documentExists",
    "operationsApplied",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "data": {
    "cart": [
      {
        "sku": "BEANS-500",
        "quantity": 1
      }
    ],
    "currency": "USD"
  },
  "patch": [
    {
      "op": "test",
      "path": "/currency",
      "value": "USD"
    },
    {
      "op": "replace",
      "path": "/cart/0/quantity",
      "value": 2
    },
    {
      "op": "add",
      "path": "/cart/-",
      "value": {
        "sku": "MUG",
        "quantity": 1
      }
    }
  ]
}
```

---

# html.metadata

Extract title, description, canonical URL, language and social metadata from supplied HTML.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.metadata

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    },
    "baseUrl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "title": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "language": {
      "type": "string"
    },
    "canonicalUrl": {
      "type": [
        "string",
        "null"
      ]
    },
    "robots": {
      "type": "string"
    },
    "social": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        },
        "required": [
          "name",
          "content"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "title",
    "description",
    "language",
    "canonicalUrl",
    "robots",
    "social"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<html lang=\"en\"><head><title>Shop</title><link rel=\"canonical\" href=\"/shop\"><meta name=\"description\" content=\"Our cups\"></head><body><h1>Cups</h1><a href=\"/cup\">Blue cup</a></body></html>",
  "baseUrl": "https://example.com/"
}
```

---

# html.links

Extract up to 200 links and resolve HTTP(S) destinations against the supplied page URL.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.links

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    },
    "baseUrl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "links": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "href": {
            "type": "string"
          },
          "url": {
            "type": [
              "string",
              "null"
            ]
          },
          "text": {
            "type": "string"
          },
          "rel": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "href",
          "url",
          "text",
          "rel"
        ],
        "additionalProperties": false
      }
    },
    "total": {
      "type": "number"
    },
    "truncated": {
      "type": "boolean"
    }
  },
  "required": [
    "links",
    "total",
    "truncated"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<html lang=\"en\"><head><title>Shop</title><link rel=\"canonical\" href=\"/shop\"><meta name=\"description\" content=\"Our cups\"></head><body><h1>Cups</h1><a href=\"/cup\">Blue cup</a></body></html>",
  "baseUrl": "https://example.com/"
}
```

---

# html.headings

Extract up to 200 headings with parent indices and skipped-level indicators.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.headings

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "headings": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "level": {
            "type": "number"
          },
          "text": {
            "type": "string"
          },
          "id": {
            "type": "string"
          },
          "parentIndex": {
            "type": [
              "number",
              "null"
            ]
          },
          "skippedLevel": {
            "type": "boolean"
          }
        },
        "required": [
          "level",
          "text",
          "id",
          "parentIndex",
          "skippedLevel"
        ],
        "additionalProperties": false
      }
    },
    "total": {
      "type": "number"
    },
    "truncated": {
      "type": "boolean"
    }
  },
  "required": [
    "headings",
    "total",
    "truncated"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<h1>Guide</h1><h3>Setup</h3>"
}
```

---

# html.forms

Describe up to 30 forms and their controls without returning field values or submitting anything.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.forms

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    },
    "baseUrl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "forms": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "action": {
            "type": [
              "string",
              "null"
            ]
          },
          "method": {
            "type": "string"
          },
          "fields": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": {
                  "type": "string"
                },
                "type": {
                  "type": "string"
                },
                "label": {
                  "type": "string"
                },
                "required": {
                  "type": "boolean"
                },
                "disabled": {
                  "type": "boolean"
                }
              },
              "required": [
                "name",
                "type",
                "label",
                "required",
                "disabled"
              ],
              "additionalProperties": false
            }
          },
          "fieldsTruncated": {
            "type": "boolean"
          }
        },
        "required": [
          "id",
          "action",
          "method",
          "fields",
          "fieldsTruncated"
        ],
        "additionalProperties": false
      }
    },
    "truncated": {
      "type": "boolean"
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "forms",
    "truncated",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<form action=\"/search\"><label for=\"q\">Search</label><input id=\"q\" name=\"q\" required></form>",
  "baseUrl": "https://example.com/"
}
```

---

# html.images

Extract up to 200 image URLs, alt text and source attributes; does not fetch images.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.images

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    },
    "baseUrl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "images": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "url": {
            "type": [
              "string",
              "null"
            ]
          },
          "alt": {
            "type": [
              "string",
              "null"
            ]
          },
          "width": {
            "type": "string"
          },
          "height": {
            "type": "string"
          },
          "srcset": {
            "type": "string"
          },
          "loading": {
            "type": "string"
          }
        },
        "required": [
          "url",
          "alt",
          "width",
          "height",
          "srcset",
          "loading"
        ],
        "additionalProperties": false
      }
    },
    "total": {
      "type": "number"
    },
    "truncated": {
      "type": "boolean"
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "images",
    "total",
    "truncated",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<img src=\"/cup.png\" alt=\"Blue cup\" width=\"200\">",
  "baseUrl": "https://example.com/"
}
```

---

# html.feeds

Discover up to 50 RSS, Atom and JSON Feed links declared in supplied HTML.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/html.feeds

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    },
    "baseUrl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "feeds": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "url": {
            "type": [
              "string",
              "null"
            ]
          },
          "type": {
            "type": "string"
          },
          "title": {
            "type": "string"
          }
        },
        "required": [
          "url",
          "type",
          "title"
        ],
        "additionalProperties": false
      }
    },
    "truncated": {
      "type": "boolean"
    }
  },
  "required": [
    "feeds",
    "truncated"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<link rel=\"alternate\" type=\"application/rss+xml\" href=\"/feed.xml\">",
  "baseUrl": "https://example.com/"
}
```

---

# data.json-pointer

Select JSON values with up to 100 RFC 6901 pointer strings, preserving missing versus null.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/data.json-pointer

Input schema:
```json
{
  "type": "object",
  "properties": {
    "data": {},
    "paths": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 2048
      },
      "maxItems": 100
    }
  },
  "required": [
    "data",
    "paths"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "selections": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "pointer": {
            "type": "string"
          },
          "found": {
            "type": "boolean"
          },
          "value": {}
        },
        "required": [
          "pointer",
          "found"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "selections"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "data": {
    "product": {
      "name": "Cup"
    }
  },
  "paths": [
    "/product/name",
    "/price"
  ]
}
```

---

# data.json-diff

Compare JSON structures and return bounded changes at JSON Pointer paths.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/data.json-diff

Input schema:
```json
{
  "type": "object",
  "properties": {
    "before": {},
    "after": {},
    "maxChanges": {
      "type": "integer",
      "minimum": 1,
      "maximum": 200
    }
  },
  "required": [
    "before",
    "after"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "equal": {
      "type": "boolean"
    },
    "changes": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          },
          "before": {},
          "after": {}
        },
        "required": [
          "path",
          "kind"
        ],
        "additionalProperties": false
      }
    },
    "truncated": {
      "type": "boolean"
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "equal",
    "changes",
    "truncated",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "before": {
    "price": 10
  },
  "after": {
    "price": 12,
    "inStock": true
  }
}
```

---

# data.json-canonical

Serialize JSON with sorted object keys for deterministic comparison; not RFC 8785 certification.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/data.json-canonical

Input schema:
```json
{
  "type": "object",
  "properties": {
    "data": {}
  },
  "required": [
    "data"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "profile": {
      "type": "string"
    }
  },
  "required": [
    "text",
    "profile"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "data": {
    "z": 2,
    "a": 1
  }
}
```

---

# security.jwt-inspect

Decode untrusted JWT claims and optionally compare timestamps; never verifies a signature.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/security.jwt-inspect

Input schema:
```json
{
  "type": "object",
  "properties": {
    "token": {
      "type": "string",
      "minLength": 1,
      "maxLength": 20000
    },
    "atUnixSeconds": {
      "type": "integer",
      "minimum": 0
    }
  },
  "required": [
    "token"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "header": {
      "type": "object"
    },
    "claims": {
      "type": "object"
    },
    "signatureVerified": {
      "const": false
    },
    "expired": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "notYetValid": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "warnings": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "header",
    "claims",
    "signatureVerified",
    "expired",
    "notYetValid",
    "warnings",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "token": "eyJhbGciOiJub25lIn0.eyJzdWIiOiJkZW1vIn0."
}
```

---

# security.csp-audit

Parse a supplied Content Security Policy and flag selected risky or missing directives.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/security.csp-audit

Input schema:
```json
{
  "type": "object",
  "properties": {
    "policy": {
      "type": "string",
      "maxLength": 16000
    }
  },
  "required": [
    "policy"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "directives": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "sources": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "name",
          "sources"
        ],
        "additionalProperties": false
      }
    },
    "findings": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "rule": {
            "type": "string"
          },
          "severity": {
            "type": "string"
          },
          "message": {
            "type": "string"
          }
        },
        "required": [
          "rule",
          "severity",
          "message"
        ],
        "additionalProperties": false
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "directives",
    "findings",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "policy": "default-src 'self'; object-src 'none'; base-uri 'self'; frame-ancestors 'none'"
}
```

---

# security.header-audit

Review supplied response headers for selected security and CORS issues without echoing values.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/security.header-audit

Input schema:
```json
{
  "type": "object",
  "properties": {
    "headers": {
      "type": "object",
      "maxProperties": 100,
      "additionalProperties": {
        "type": "string",
        "maxLength": 8192
      }
    }
  },
  "required": [
    "headers"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "headerNames": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "findings": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "rule": {
            "type": "string"
          },
          "severity": {
            "type": "string"
          },
          "message": {
            "type": "string"
          }
        },
        "required": [
          "rule",
          "severity",
          "message"
        ],
        "additionalProperties": false
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "headerNames",
    "findings",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "headers": {
    "X-Content-Type-Options": "nosniff"
  }
}
```

---

# security.cookie-audit

Check up to 50 Set-Cookie headers for security attributes and prefix rules; masks cookie values.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/security.cookie-audit

Input schema:
```json
{
  "type": "object",
  "properties": {
    "setCookies": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 8192
      },
      "maxItems": 50
    }
  },
  "required": [
    "setCookies"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "cookies": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "value": {
            "const": "[REDACTED]"
          },
          "secure": {
            "type": "boolean"
          },
          "httpOnly": {
            "type": "boolean"
          },
          "sameSite": {
            "type": "string"
          },
          "hasDomain": {
            "type": "boolean"
          },
          "findings": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "rule": {
                  "type": "string"
                },
                "severity": {
                  "type": "string"
                },
                "message": {
                  "type": "string"
                }
              },
              "required": [
                "rule",
                "severity",
                "message"
              ],
              "additionalProperties": false
            }
          }
        },
        "required": [
          "name",
          "value",
          "secure",
          "httpOnly",
          "sameSite",
          "hasDomain",
          "findings"
        ],
        "additionalProperties": false
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "cookies",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "setCookies": [
    "demo=example; Secure; HttpOnly; SameSite=Lax; Path=/"
  ]
}
```

---

# agents.env-template-check

Compare environment-variable names against a template; never returns assignment values.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/agents.env-template-check

Input schema:
```json
{
  "type": "object",
  "properties": {
    "template": {
      "type": "string",
      "maxLength": 100000
    },
    "actual": {
      "type": "string",
      "maxLength": 100000
    }
  },
  "required": [
    "template",
    "actual"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "missing": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "extra": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "duplicateNames": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "templateDuplicateNames": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "unrecognizedLines": {
      "type": "object",
      "properties": {
        "template": {
          "type": "number"
        },
        "actual": {
          "type": "number"
        }
      },
      "required": [
        "template",
        "actual"
      ],
      "additionalProperties": false
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "missing",
    "extra",
    "duplicateNames",
    "templateDuplicateNames",
    "unrecognizedLines",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "template": "APP_URL=\nLOG_LEVEL=",
  "actual": "APP_URL=https://example.com"
}
```

---

# agents.tool-name-conflicts

Find duplicate or easily confused tool names after Unicode, case and separator normalization.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/agents.tool-name-conflicts

Input schema:
```json
{
  "type": "object",
  "properties": {
    "names": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 200
      },
      "maxItems": 200
    }
  },
  "required": [
    "names"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "conflicts": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "normalized": {
            "type": "string"
          },
          "kind": {
            "type": "string"
          },
          "items": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": {
                  "type": "string"
                },
                "index": {
                  "type": "number"
                }
              },
              "required": [
                "name",
                "index"
              ],
              "additionalProperties": false
            }
          }
        },
        "required": [
          "normalized",
          "kind",
          "items"
        ],
        "additionalProperties": false
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "conflicts",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "names": [
    "get_price",
    "Get-Price",
    "checkout"
  ]
}
```

---

# text.chunk

Split text into at most 200 overlapping chunks with offsets and intact UTF-16 surrogate pairs.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/text.chunk

Input schema:
```json
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 100000
    },
    "maxChars": {
      "type": "integer",
      "minimum": 32,
      "maximum": 10000
    },
    "overlap": {
      "type": "integer",
      "minimum": 0,
      "maximum": 500
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "chunks": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "start": {
            "type": "number"
          },
          "end": {
            "type": "number"
          },
          "text": {
            "type": "string"
          }
        },
        "required": [
          "start",
          "end",
          "text"
        ],
        "additionalProperties": false
      }
    },
    "offsetUnit": {
      "type": "string"
    },
    "count": {
      "type": "number"
    }
  },
  "required": [
    "chunks",
    "offsetUnit",
    "count"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "text": "Agents can reuse bounded snippets of a longer document.",
  "maxChars": 32,
  "overlap": 8
}
```

---

# commerce.gtin-validate

Validate GTIN-8, UPC/GTIN-12, EAN/GTIN-13 and GTIN-14 check digits; no product lookup.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/commerce.gtin-validate

Input schema:
```json
{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "maxLength": 32
    }
  },
  "required": [
    "code"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "valid": {
      "type": "boolean"
    },
    "format": {
      "type": "string"
    },
    "expectedCheckDigit": {
      "type": [
        "string",
        "null"
      ]
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "valid",
    "format",
    "expectedCheckDigit",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "code": "036000291452"
}
```

---

# commerce.variant-compare

Compare requested product attributes with an offered variant and list missing or mismatched fields.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/commerce.variant-compare

Input schema:
```json
{
  "type": "object",
  "properties": {
    "requested": {
      "type": "object",
      "maxProperties": 100
    },
    "offered": {
      "type": "object",
      "maxProperties": 100
    }
  },
  "required": [
    "requested",
    "offered"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "matches": {
      "type": "boolean"
    },
    "missing": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "mismatched": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "attribute": {
            "type": "string"
          },
          "requested": {},
          "offered": {}
        },
        "required": [
          "attribute",
          "requested",
          "offered"
        ],
        "additionalProperties": false
      }
    },
    "extra": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "matches",
    "missing",
    "mismatched",
    "extra",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "requested": {
    "color": "blue",
    "size": "M"
  },
  "offered": {
    "color": "blue",
    "size": "L",
    "stock": true
  }
}
```

---

# commerce.pack-plan

Choose the lowest-cost whole-pack combination for a required count with exact prices and explicit pack limits; up to 20 interchangeable offers.

Price: 800 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/commerce.pack-plan

Input schema:
```json
{
  "type": "object",
  "properties": {
    "currency": {
      "type": "string",
      "pattern": "^[A-Z]{3}$"
    },
    "minorUnitDigits": {
      "type": "integer",
      "minimum": 0,
      "maximum": 6
    },
    "requiredUnits": {
      "type": "integer",
      "minimum": 1,
      "maximum": 1000
    },
    "offers": {
      "type": "array",
      "minItems": 1,
      "maxItems": 20,
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 100
          },
          "unitsPerPack": {
            "type": "integer",
            "minimum": 1,
            "maximum": 1000
          },
          "price": {
            "type": "string",
            "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
            "maxLength": 19
          },
          "maxPacks": {
            "type": "integer",
            "minimum": 0,
            "maximum": 1000
          }
        },
        "required": [
          "id",
          "unitsPerPack",
          "price",
          "maxPacks"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "currency",
    "minorUnitDigits",
    "requiredUnits",
    "offers"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "currency": {
      "type": "string"
    },
    "minorUnitDigits": {
      "type": "number"
    },
    "requiredUnits": {
      "type": "number"
    },
    "feasible": {
      "type": "boolean"
    },
    "totalUnits": {
      "type": [
        "integer",
        "null"
      ]
    },
    "excessUnits": {
      "type": [
        "integer",
        "null"
      ]
    },
    "itemSubtotal": {
      "type": [
        "string",
        "null"
      ]
    },
    "packCount": {
      "type": [
        "integer",
        "null"
      ]
    },
    "lines": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "packs": {
            "type": "number"
          },
          "units": {
            "type": "number"
          },
          "lineSubtotal": {
            "type": "string"
          }
        },
        "required": [
          "id",
          "packs",
          "units",
          "lineSubtotal"
        ],
        "additionalProperties": false
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "currency",
    "minorUnitDigits",
    "requiredUnits",
    "feasible",
    "totalUnits",
    "excessUnits",
    "itemSubtotal",
    "packCount",
    "lines",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "currency": "USD",
  "minorUnitDigits": 2,
  "requiredUnits": 12,
  "offers": [
    {
      "id": "six-pack",
      "unitsPerPack": 6,
      "price": "7.99",
      "maxPacks": 10
    },
    {
      "id": "ten-pack",
      "unitsPerPack": 10,
      "price": "11.99",
      "maxPacks": 10
    }
  ]
}
```

---

# commerce.money-parse

Normalize up to 50 displayed prices with explicit locale, currency and decimal scale; exact amounts, strict grouping and per-price errors.

Price: 300 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/commerce.money-parse

Input schema:
```json
{
  "type": "object",
  "properties": {
    "locale": {
      "type": "string",
      "enum": [
        "en-US",
        "en-GB",
        "de-DE",
        "fr-FR",
        "en-IN"
      ]
    },
    "currency": {
      "type": "string",
      "enum": [
        "USD",
        "EUR",
        "GBP",
        "CAD",
        "AUD",
        "JPY",
        "INR"
      ]
    },
    "minorUnitDigits": {
      "type": "integer",
      "minimum": 0,
      "maximum": 6
    },
    "amounts": {
      "type": "array",
      "minItems": 1,
      "maxItems": 50,
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 100
          },
          "text": {
            "type": "string",
            "minLength": 1,
            "maxLength": 100
          }
        },
        "required": [
          "id",
          "text"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "locale",
    "currency",
    "minorUnitDigits",
    "amounts"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "locale": {
      "type": "string"
    },
    "currency": {
      "type": "string"
    },
    "minorUnitDigits": {
      "type": "number"
    },
    "amounts": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "valid": {
            "type": "boolean"
          },
          "amount": {
            "type": [
              "string",
              "null"
            ]
          },
          "minorUnits": {
            "type": [
              "string",
              "null"
            ]
          },
          "currencyToken": {
            "type": [
              "string",
              "null"
            ]
          },
          "issue": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "id",
          "valid",
          "amount",
          "minorUnits",
          "currencyToken",
          "issue"
        ],
        "additionalProperties": false
      }
    },
    "allValid": {
      "type": "boolean"
    },
    "acceptedCurrencyTokens": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "locale",
    "currency",
    "minorUnitDigits",
    "amounts",
    "allValid",
    "acceptedCurrencyTokens",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "locale": "de-DE",
  "currency": "EUR",
  "minorUnitDigits": 2,
  "amounts": [
    {
      "id": "offer-1",
      "text": "1.234,56 €"
    },
    {
      "id": "offer-2",
      "text": "EUR 999,95"
    },
    {
      "id": "range",
      "text": "10–20 €"
    }
  ]
}
```

---

# commerce.offer-extract

Extract bounded Product offers from supplied JSON-LD HTML with source pointers, missing-price warnings and separate aggregate ranges.

Price: 800 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/commerce.offer-extract

Input schema:
```json
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "maxLength": 100000
    },
    "baseUrl": {
      "type": "string",
      "maxLength": 2048
    },
    "maxOffers": {
      "type": "integer",
      "minimum": 1,
      "maximum": 50
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "offers": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "productName": {
            "type": [
              "string",
              "null"
            ]
          },
          "sku": {
            "type": [
              "string",
              "null"
            ]
          },
          "gtin": {
            "type": [
              "string",
              "null"
            ]
          },
          "offerType": {
            "type": "string"
          },
          "price": {
            "type": [
              "string",
              "null"
            ]
          },
          "currency": {
            "type": [
              "string",
              "null"
            ]
          },
          "lowPrice": {
            "type": [
              "string",
              "null"
            ]
          },
          "highPrice": {
            "type": [
              "string",
              "null"
            ]
          },
          "url": {
            "type": [
              "string",
              "null"
            ]
          },
          "availability": {
            "type": [
              "string",
              "null"
            ]
          },
          "itemCondition": {
            "type": [
              "string",
              "null"
            ]
          },
          "priceValidUntil": {
            "type": [
              "string",
              "null"
            ]
          },
          "source": {
            "type": "object",
            "properties": {
              "productBlock": {
                "type": "number"
              },
              "productPointer": {
                "type": "string"
              },
              "offerBlock": {
                "type": "number"
              },
              "offerPointer": {
                "type": "string"
              }
            },
            "required": [
              "productBlock",
              "productPointer",
              "offerBlock",
              "offerPointer"
            ],
            "additionalProperties": false
          },
          "warnings": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "productName",
          "sku",
          "gtin",
          "offerType",
          "price",
          "currency",
          "lowPrice",
          "highPrice",
          "url",
          "availability",
          "itemCondition",
          "priceValidUntil",
          "source",
          "warnings"
        ],
        "additionalProperties": false
      }
    },
    "productsFound": {
      "type": "number"
    },
    "productsWithoutOffers": {
      "type": "number"
    },
    "invalidBlocks": {
      "type": "number"
    },
    "unresolvedReferences": {
      "type": "number"
    },
    "unsupportedOffers": {
      "type": "number"
    },
    "truncated": {
      "type": "boolean"
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "offers",
    "productsFound",
    "productsWithoutOffers",
    "invalidBlocks",
    "unresolvedReferences",
    "unsupportedOffers",
    "truncated",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "html": "<script type=\"application/ld+json\">{\"@context\":\"https://schema.org\",\"@type\":\"Product\",\"name\":\"Coffee beans, 500 g\",\"sku\":\"BEANS-500\",\"offers\":{\"@type\":\"Offer\",\"price\":\"8.99\",\"priceCurrency\":\"USD\",\"availability\":\"https://schema.org/InStock\",\"url\":\"/beans\"}}</script>",
  "baseUrl": "https://example.com/shop"
}
```

---

# commerce.unit-price

Compare up to 50 explicit pack prices with exact arithmetic across compatible mass, volume or count units; no currency conversion.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/commerce.unit-price

Input schema:
```json
{
  "type": "object",
  "properties": {
    "currency": {
      "type": "string",
      "pattern": "^[A-Z]{3}$"
    },
    "reference": {
      "type": "object",
      "properties": {
        "quantity": {
          "type": "string",
          "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
          "maxLength": 19
        },
        "unit": {
          "type": "string",
          "enum": [
            "mg",
            "g",
            "kg",
            "oz",
            "lb",
            "ml",
            "l",
            "each"
          ]
        }
      },
      "required": [
        "quantity",
        "unit"
      ],
      "additionalProperties": false
    },
    "offers": {
      "type": "array",
      "minItems": 1,
      "maxItems": 50,
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 100
          },
          "price": {
            "type": "string",
            "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
            "maxLength": 19
          },
          "quantity": {
            "type": "string",
            "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
            "maxLength": 19
          },
          "unit": {
            "type": "string",
            "enum": [
              "mg",
              "g",
              "kg",
              "oz",
              "lb",
              "ml",
              "l",
              "each"
            ]
          },
          "packCount": {
            "type": "integer",
            "minimum": 1,
            "maximum": 10000
          }
        },
        "required": [
          "id",
          "price",
          "quantity",
          "unit"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "currency",
    "reference",
    "offers"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "currency": {
      "type": "string"
    },
    "reference": {
      "type": "object",
      "properties": {
        "quantity": {
          "type": "string",
          "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
          "maxLength": 19
        },
        "unit": {
          "type": "string",
          "enum": [
            "mg",
            "g",
            "kg",
            "oz",
            "lb",
            "ml",
            "l",
            "each"
          ]
        }
      },
      "required": [
        "quantity",
        "unit"
      ],
      "additionalProperties": false
    },
    "offers": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "totalQuantity": {
            "type": "object",
            "properties": {
              "numerator": {
                "type": "string"
              },
              "denominator": {
                "type": "string"
              },
              "unit": {
                "type": "string"
              }
            },
            "required": [
              "numerator",
              "denominator",
              "unit"
            ],
            "additionalProperties": false
          },
          "pricePerReference": {
            "type": "string"
          },
          "exactPricePerReference": {
            "type": "object",
            "properties": {
              "numerator": {
                "type": "string"
              },
              "denominator": {
                "type": "string"
              }
            },
            "required": [
              "numerator",
              "denominator"
            ],
            "additionalProperties": false
          }
        },
        "required": [
          "id",
          "totalQuantity",
          "pricePerReference",
          "exactPricePerReference"
        ],
        "additionalProperties": false
      }
    },
    "cheapestIds": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "currency",
    "reference",
    "offers",
    "cheapestIds",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "currency": "USD",
  "reference": {
    "quantity": "100",
    "unit": "g"
  },
  "offers": [
    {
      "id": "500g-bag",
      "price": "8.99",
      "quantity": "500",
      "unit": "g"
    },
    {
      "id": "1kg-bag",
      "price": "16.49",
      "quantity": "1",
      "unit": "kg"
    }
  ]
}
```

---

# commerce.price-components

Reconcile item, discount, shipping, tax and fee amounts using exact decimals; missing costs stay unknown and declared totals can be checked.

Price: 500 micro-dollar credits per successful call.

Page: https://agent-utilities.agent-utilities.workers.dev/tools/commerce.price-components

Input schema:
```json
{
  "type": "object",
  "properties": {
    "currency": {
      "type": "string",
      "pattern": "^[A-Z]{3}$"
    },
    "minorUnitDigits": {
      "type": "integer",
      "minimum": 0,
      "maximum": 6
    },
    "items": {
      "type": "array",
      "minItems": 1,
      "maxItems": 100,
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "minLength": 1,
            "maxLength": 100
          },
          "unitPrice": {
            "type": "string",
            "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
            "maxLength": 19
          },
          "quantity": {
            "type": "integer",
            "minimum": 1,
            "maximum": 100000
          },
          "discount": {
            "type": "string",
            "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
            "maxLength": 19
          }
        },
        "required": [
          "id",
          "unitPrice",
          "quantity",
          "discount"
        ],
        "additionalProperties": false
      }
    },
    "orderDiscount": {
      "type": "string",
      "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
      "maxLength": 19
    },
    "shipping": {
      "anyOf": [
        {
          "type": "string",
          "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
          "maxLength": 19
        },
        {
          "type": "null"
        }
      ]
    },
    "tax": {
      "anyOf": [
        {
          "type": "string",
          "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
          "maxLength": 19
        },
        {
          "type": "null"
        }
      ]
    },
    "fees": {
      "anyOf": [
        {
          "type": "string",
          "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
          "maxLength": 19
        },
        {
          "type": "null"
        }
      ]
    },
    "declaredTotal": {
      "type": "string",
      "pattern": "^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$",
      "maxLength": 19
    }
  },
  "required": [
    "currency",
    "minorUnitDigits",
    "items",
    "orderDiscount",
    "shipping",
    "tax",
    "fees"
  ],
  "additionalProperties": false
}
```

Output schema:
```json
{
  "type": "object",
  "properties": {
    "currency": {
      "type": "string"
    },
    "minorUnitDigits": {
      "type": "number"
    },
    "lines": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "subtotal": {
            "type": "string"
          },
          "discount": {
            "type": "string"
          },
          "total": {
            "type": "string"
          }
        },
        "required": [
          "id",
          "subtotal",
          "discount",
          "total"
        ],
        "additionalProperties": false
      }
    },
    "itemSubtotal": {
      "type": "string"
    },
    "lineDiscounts": {
      "type": "string"
    },
    "orderDiscount": {
      "type": "string"
    },
    "knownTotal": {
      "type": "string"
    },
    "total": {
      "type": [
        "string",
        "null"
      ]
    },
    "missingComponents": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "matchesDeclaredTotal": {
      "type": [
        "boolean",
        "null"
      ]
    },
    "difference": {
      "type": [
        "string",
        "null"
      ]
    },
    "scope": {
      "type": "string"
    }
  },
  "required": [
    "currency",
    "minorUnitDigits",
    "lines",
    "itemSubtotal",
    "lineDiscounts",
    "orderDiscount",
    "knownTotal",
    "total",
    "missingComponents",
    "matchesDeclaredTotal",
    "difference",
    "scope"
  ],
  "additionalProperties": false
}
```

Example input:
```json
{
  "currency": "USD",
  "minorUnitDigits": 2,
  "items": [
    {
      "id": "1kg-bag",
      "unitPrice": "16.49",
      "quantity": 2,
      "discount": "0.00"
    }
  ],
  "orderDiscount": "2.00",
  "shipping": "4.99",
  "tax": null,
  "fees": "0.00"
}
```