nanoparse-mcp 1.0.9 → 2.0.1

package/CHANGELOG.md

@@ -0,0 +1,78 @@
+## 2.0.1 — 2026-11-14
+
+- Price: $0.005 → **$0.002** per parse. Copy only: the hosted endpoint takes the
+  amount from the live 402 challenge, so no client change is needed.
+
+# Changelog
+
+All notable changes to nanoparse-mcp will be documented in this file.
+
+---
+
+## [2.0.0] - 2026-08-28
+
+### Changed
+
+- Repo restructured as the public home for the **hosted** MCP endpoint
+  (`https://nanoparse.app/mcp`): docs + real examples, no client code.
+- Retired v1 local stdio client moved to `archive/v1-local-client/`
+  (was `src/`), with a DEPRECATED banner. The client held a wallet private
+  key locally (`NANOPARSE_WALLET_KEY`) and is replaced by the hosted
+  endpoint's own payment flow.
+- npm package `nanoparse-mcp` deprecated — use the hosted endpoint.
+- README: real Litmus output example (arXiv parse), worked agent
+  conversation, cost comparison vs Firecrawl (verified Aug 2026), new
+  `examples/` directory (`example-output.json`, `agent-conversation.md`,
+  `costs.md`).
+- Price: $0.01 → **$0.005** per parse (2026-10-06), with the README and
+  examples realigned.
+- `package.json`: **removed `main`, `bin`, `files: ["dist/"]` and the build
+  scripts.** After the client source moved to `archive/v1-local-client/` they
+  pointed at `dist/index.js`, which no longer exists — so `npm run build` failed
+  and a publish would have shipped a package containing only LICENSE, README and
+  package.json. Runtime dependencies (`@modelcontextprotocol/sdk`, `viem`) went
+  with the client.
+
+### Published 2026-10-06
+
+First publish of the 2.0.0 line. Versions ≤ 1.0.9 ship the retired local stdio
+client and are deprecated on the registry.
+
+## [1.0.9] - 2026-08-23
+
+### Changed
+
+- Price: $0.0175 → **$0.01** per parse (tool descriptions + README)
+- README: removed dead card-pack section (`/payments` not live); docs links now point to live pages (`/quickstart`, `/compare`)
+- Server version string synced with package version
+
+## [1.0.8] - 2026-08-23
+
+### Changed
+
+- Price: $0.0175 → **$0.01** per parse in `nanoparse_fetch` tool description
+
+## [1.0.7] - 2026-08-17
+
+### Changed
+
+- Local stdio client retired — hosted MCP endpoint (`https://nanoparse.app/mcp`) is the only supported integration
+- README rewritten as customer guide to the hosted MCP
+
+## [1.0.2] - 2026-08-02
+
+### Fixed
+
+- Added missing `#!/usr/bin/env node` shebang to `dist/index.js`. Plain `npx nanoparse-mcp` now works without requiring `node dist/index.js`. Added `postbuild` script to prepend shebang after `tsc` compilation and set execute permissions.
+
+## [1.0.1] - 2026-08-01
+
+### Changed
+
+- Updated `nanoparse_fetch` tool description
+
+## [1.0.0] - 2026-07-26 — Initial release
+
+- MCP server with stdio transport, single tool: `nanoparse_fetch(url, debug?)`
+- x402 payment signing via viem (wallet key from `NANOPARSE_WALLET_KEY` env var)
+- Thin client only — browser rendering and content scoring run on NanoParse's infrastructure

package/README.md

@@ -1,9 +1,18 @@
 # NanoParse MCP
 
-**Give your AI agent clean, structured web content.** NanoParse MCP is a hosted Model Context Protocol server at `https://nanoparse.app/mcp` that turns any URL into clean Markdown your agent can actually use — with machine-readable trust signals attached.
+[![npm version](https://img.shields.io/npm/v/nanoparse-mcp)](https://www.npmjs.com/package/nanoparse-mcp)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Website](https://img.shields.io/badge/web-nanoparse.app-22D3EE)](https://nanoparse.app)
+[![MCP Score](https://checkmcp.dev/badge/nanoparse-app.svg?url=https%3A%2F%2Fnanoparse.app%2Fmcp)](https://checkmcp.dev/mcp/nanoparse-app)
+[![MCPLookup Trust Index](https://mcplookup.com/badge/io.github.nanoparse-dev/nanoparse-mcp)](https://mcplookup.com/server/io.github.nanoparse-dev/nanoparse-mcp)
+[![Listed on HookMCP](https://hookmcp.com/badge.svg)](https://hookmcp.com)
+
+**The easiest way for AI agents to read the web.** NanoParse MCP is a hosted Model Context Protocol server at `https://nanoparse.app/mcp` that turns any URL into clean Markdown your agent can actually use — with machine-readable trust signals attached.
 
 No install. No wallet key. No `.env`. Connect once and your agent can read the web.
 
+**Why agents choose NanoParse over Firecrawl or Jina Reader:** every page comes back with **Litmus** — 20 machine-readable signals that tell your agent *whether to trust and cite the page* before it reads a word. Pay $0.002 per parse via x402 once the free tier runs out. Full JavaScript/SPA rendering, native GFM tables. No account, no subscription, no API key.
+
 ## Quick start
 
 Add this to your MCP client config:
@@ -12,6 +21,7 @@ Add this to your MCP client config:
 {
   "mcpServers": {
     "nanoparse": {
+      "type": "http",
       "url": "https://nanoparse.app/mcp"
     }
   }
@@ -35,33 +45,83 @@ That's it. Your agent can now fetch pages from inside any MCP-compatible client
 
 `nanoparse_status` tells your agent exactly where it stands: free parses remaining, wallet and USDC balance, and whether the next call will succeed without payment. Agents call it before spending.
 
+## Real output
+
+Every parse returns `markdown` + `metadata` + `litmus`. Here is the full `litmus` object from a real parse of an arXiv paper (`examples/example-output.json` — markdown truncated there, litmus complete and unmodified):
+
+```json
+{
+  "litmus": {
+    "source": { "type": "academic", "authority": 0.85, "rationale": "academic source" },
+    "freshness": { "published": null, "age": "unknown", "stale_warning": "No publish date found — verify independently", "modified": null, "has_correction": false, "correction_note": null },
+    "tldr": "Abstract page for arXiv paper 2401.14295: Demystifying Chains, Trees, and Graphs of Thoughts",
+    "key_figures": [ { "value": "2,247", "context": "Thu, 25 Jan 2024 16:34:00 UTC (2,247 KB)" } ],
+    "structural_trust_score": { "level": "medium", "trust_factors": ["High-authority source", "No publish date found — verify independently"] },
+    "hedge_language": { "density": "low", "markers_found": 0, "per_500_words": 0 },
+    "content_density": { "thin_content": false, "substantive_sentence_ratio": 0.76 },
+    "syndication": { "detected": false, "note": null },
+    "paywall": { "detected": false, "note": null },
+    "content_type": "academic_paper",
+    "reading_time": { "minutes": 4 },
+    "is_archived": { "archive_org": true, "archive_is": false },
+    "outbound_authority": { "score": 0.54, "top_domains": ["ui.adsabs.harvard.edu", "scholar.google.com"] },
+    "boilerplate_ratio": { "ratio": 0.08, "confidence": "high" }
+  }
+}
+```
+
+The agent learns *before reading a word*: this is an academic source (0.85 authority), structural trust is **medium** — high authority, but no publish date found, so verify independently. It also gets the one-sentence summary, the key numbers, and confirmation there's no paywall or syndication flag. See [`examples/agent-conversation.md`](examples/agent-conversation.md) for a full worked round-trip.
+
 ## Payments
 
-- **First 10 parses per device are free.** No account, no API key, no human required.
-- **After that: $0.01 per parse** (flat, no subscriptions) via **x402** — an open micropayment protocol. Your agent's wallet signs the payment automatically. To give your agent a Coinbase wallet, run `npx @coinbase/payments-mcp` and connect it alongside NanoParse.
+- **10 free parses per month with a signed wallet** (sign the claim message — no payment), or 3 anonymous free tries per network. No account, no API key, no human required.
+- **After that: $0.002 per parse** (flat, no subscriptions) via **x402** — an open micropayment protocol. Your agent's wallet signs the payment automatically. To give your agent a Coinbase wallet, run `npx @coinbase/payments-mcp` and connect it alongside NanoParse.
+
+Copy-paste recipe for both paths — the wallet-MCP one with no code, and a ~40-line REST client — including the exact `402 → sign → retry` loop and the error codes worth branching on: [`examples/pay-with-x402.md`](examples/pay-with-x402.md).
 
 ## How payments work under the hood
 
-When an agent without free quota calls `nanoparse_fetch`, the endpoint responds with an **HTTP 402 — Payment Required** carrying x402 payment instructions. The agent's wallet signs a $0.01 USDC (Base) transfer, the facilitator settles it, and the parse proceeds. The hosted endpoint handles the entire challenge → settlement flow — the agent never needs a private key on your machine.
+When an agent without free quota calls `nanoparse_fetch`, the endpoint responds with an **HTTP 402 — Payment Required** carrying x402 payment instructions. The agent's wallet signs a $0.002 USDC (Base) transfer, the facilitator settles it, and the parse proceeds. The hosted endpoint handles the entire challenge → settlement flow — the agent never needs a private key on your machine.
+
+## Pricing vs Firecrawl
+
+| | NanoParse | Firecrawl Hobby |
+|---|---|---|
+| Billing | **$0.002 per parse, flat** | $16/mo subscription, credits expire monthly |
+| 5,000 parses | **$25.00** | $16 base — but ~$145 with JSON/extraction modes (9× credit burn) |
+| Account / API key | **None** | Required |
+| Agent can pay directly (x402) | **Yes** | No |
+
+Full math, including when Firecrawl's base rate wins at scale: [`examples/costs.md`](examples/costs.md).
 
 ## Example
 
 ```
-You: Fetch https://www.ft.com/content/... and summarize the argument.
+You: Fetch https://arxiv.org/abs/2401.14295 and summarize the argument.
 
 Agent: [calls nanoparse_fetch(url)]
-       → clean Markdown + Litmus signals
-       → summarizes from primary content, cites freshness and authority
+       → clean Markdown + Litmus (academic, authority 0.85, 4-min read,
+         no date found — verify, no paywall)
+       → summarizes from primary content, cites authority and freshness
 ```
 
 ## Repository note
 
-The `nanoparse-mcp` npm package previously published here was the first-generation local client, which held a wallet private key and signed x402 payments on your machine. It is retired: the hosted MCP endpoint now handles the full payment flow itself, so the local client is no longer needed. **Use the hosted endpoint above** — it is the current, supported integration.
+The `nanoparse-mcp` npm package and the local stdio client were the
+first-generation integration, which held a wallet private key
+(`NANOPARSE_WALLET_KEY`) and signed x402 payments on your machine. Both are
+**retired**: the hosted endpoint above now handles the full payment flow
+itself, so no local client or wallet key is needed. The retired client code
+is preserved in [`archive/v1-local-client/`](archive/v1-local-client/) for
+history, and the npm package is deprecated. **Use the hosted endpoint** — it
+is the current, supported integration.
 
 ## Docs
 
 - Quick start & integration: [nanoparse.app/quickstart](https://nanoparse.app/quickstart)
 - Compare & pricing: [nanoparse.app/compare](https://nanoparse.app/compare)
 - API + MCP endpoint: [nanoparse.app](https://nanoparse.app)
+- Security policy: [SECURITY.md](SECURITY.md) — report a vulnerability to hello@nanoparse.app
+  (also published at `https://nanoparse.app/.well-known/security.txt`)
 
 MIT licensed.

package/examples/agent-conversation.md

@@ -0,0 +1,88 @@
+# Worked example: an agent reading an academic paper
+
+This is a real `nanoparse_fetch` round-trip against the hosted endpoint
+(`https://nanoparse.app/mcp`), showing what the agent sees and how it reasons
+over the Litmus signals. The full response JSON is in
+[`example-output.json`](./example-output.json).
+
+## The request
+
+```
+You: Fetch https://arxiv.org/abs/2401.14295 and tell me what this paper
+     claims, and whether I can trust it as a source.
+```
+
+The agent calls `nanoparse_fetch(url: "https://arxiv.org/abs/2401.14295")`
+and receives clean Markdown plus the Litmus object — before reading a single
+word of the paper.
+
+## What Litmus told the agent, up front
+
+```json
+{
+  "litmus": {
+    "source": {
+      "type": "academic",
+      "authority": 0.85,
+      "rationale": "academic source"
+    },
+    "freshness": {
+      "published": null,
+      "age": "unknown",
+      "stale_warning": "No publish date found — verify independently"
+    },
+    "tldr": "Abstract page for arXiv paper 2401.14295: Demystifying Chains, Trees, and Graphs of Thoughts",
+    "key_figures": [
+      { "value": "2,247", "context": "Thu, 25 Jan 2024 16:34:00 UTC (2,247 KB)" },
+      { "value": "2,290", "context": "Sat, 30 Mar 2024 16:36:33 UTC (2,290 KB)" }
+    ],
+    "structural_trust_score": {
+      "level": "medium",
+      "trust_factors": [
+        "High-authority source",
+        "No publish date found — verify independently"
+      ]
+    },
+    "content_type": "academic_paper",
+    "reading_time": { "minutes": 4 },
+    "hedge_language": { "density": "low", "markers_found": 0, "per_500_words": 0 },
+    "syndication": { "detected": false },
+    "paywall": { "detected": false }
+  }
+}
+```
+
+## How the agent reasons about it
+
+- **Structural trust: medium** — Litmus flags this as high-authority
+  (academic, 0.85) but with no publish date found, so the verdict is "verify
+  independently," not "trust blindly." The agent treats it as a solid source
+  it still needs to date-check.
+- **Authority 0.85, academic** — high-trust source class. Claims from this
+  paper can be weighed accordingly. (Litmus scores the *source class*, not
+  the truth of the content — the agent still reads and thinks.)
+- **Freshness warning** — no publish date on the abstract page. The agent
+  checks the arXiv listing in the markdown and finds version dates
+  (Jan 2024 → Feb 2025), so it cites the paper as "2024, updated 2025"
+  instead of guessing.
+- **Key figures** — file sizes are noise, so the agent ignores them; but it
+  now knows the paper exists in multiple revisions.
+- **No syndication, no paywall, low hedge density, 4-minute read** — a
+  clean, direct academic source. No red flags.
+
+## The agent's answer
+
+> The paper **"Demystifying Chains, Trees, and Graphs of Thoughts"**
+> (arXiv 2401.14295) compares chain-of-thought, tree-of-thought, and
+> graph-of-thought prompting across 12 datasets. It claims tree/graph
+> reasoning does not consistently beat plain chain-of-thought, and that
+> success depends on problem type and search strategy.
+>
+> Source note: academic (authority 0.85), first posted Jan 2024 with
+> revisions through Feb 2025. No paywall or syndication flags. Solid
+> source for a research summary; treat its negative claims about
+> tree-of-thought as one study, not settled consensus.
+
+That reasoning — *"can I trust this, how fresh is it, what kind of source
+is it, is there anything to verify"* — is exactly what Litmus pre-computes
+so the agent doesn't have to guess from raw text.

package/examples/costs.md

@@ -0,0 +1,46 @@
+# Cost comparison: NanoParse vs Firecrawl
+
+Pricing verified 2026-08-28 (Firecrawl); NanoParse updated to the current flat rate. NanoParse: **$0.002 per parse, flat** — no
+subscription, no account, no API key. Litmus signals, full JS/SPA rendering,
+and GFM tables are included in every parse — there are no feature
+multipliers.
+
+Firecrawl (published plans, Aug 2026):
+
+| Plan | Price | Credits/mo | Base cost/page |
+|---|---|---|---|
+| Free | $0 | 1,000 | — |
+| Hobby | $16/mo | 5,000 | $0.0032 |
+| Standard | $83/mo | 100,000 | $0.00083 |
+| Growth | $333/mo | 500,000 | $0.00067 |
+| Scale | $599/mo | 1,000,000 | $0.0006 |
+
+Two things the base rate hides:
+
+1. **Credits do not roll over.** A Hobby subscription is $16 every month —
+   use 1,000 of 5,000 credits and you still paid $16. NanoParse bills only
+   what you use: $5 for exactly 1,000 parses.
+2. **Feature multipliers.** JSON extraction and enhanced mode each add
+   credits per page (up to 9 credits/page combined). At Hobby that makes a
+   fully-featured parse ~$0.029/page — ~6× NanoParse's flat rate. Litmus,
+   structured output, and rendering are included in NanoParse's $0.002 with
+   no multiplier.
+
+## What a month of 5,000 parses costs
+
+| | NanoParse | Firecrawl Hobby |
+|---|---|---|
+| Subscription | None — pay per parse | $16/mo, billed every month |
+| 5,000 plain scrapes | **$25.00** | $16 (base rate) |
+| 5,000 with extraction/features | **$25.00** | ~$145 (9× credit burn) |
+| Use only 1,000 of your quota | **$5.00** | $16 (credits expire) |
+| Account / API key needed | No | Yes |
+| Agent can pay directly (x402) | Yes | No |
+
+## When Firecrawl is genuinely cheaper
+
+At scale with plain, credit-cheap scraping, Firecrawl's base rate is lower
+per page — that's their volume bet. NanoParse's bet is different: no
+subscription, no rollover loss, no multiplier, no account, and an agent can
+pay for itself with x402. If you parse occasionally, or in bursts, or via
+agents, NanoParse charges exactly for what you use.

package/examples/example-output.json

@@ -0,0 +1,101 @@
+{
+  "url": "https://arxiv.org/abs/2401.14295",
+  "parsed_at": "2026-08-28T00:00:00Z",
+  "note": "Real response from POST https://nanoparse.app/fetch (admin round, same public response shape). Markdown truncated to the first 3,000 chars for readability; metadata and litmus are complete and unmodified.",
+  "markdown_truncated": true,
+  "markdown": "# [2401.14295] Demystifying Chains, Trees, and Graphs of Thoughts\n\n--\n\n  \n    \n      # Computer Science > Computation and Language\n    \n\n    \n      **arXiv:2401.14295 (cs)\n    \n\n- \n\n  \n    \n  [Submitted on 25 Jan 2024 ([v1](https://arxiv.org/abs/2401.14295v1)), last revised 1 Apr 2026 (this version, v6)]\n    # Title:Demystifying Chains, Trees, and Graphs of Thoughts\n    Authors:[Maciej Besta](https://arxiv.org/search/cs?searchtype=author&query=Besta,+M), [Florim Memedi](https://arxiv.org/search/cs?searchtype=author&query=Memedi,+F), [Zhenyu Zhang](https://arxiv.org/search/cs?searchtype=author&query=Zhang,+Z), [Robert Gerstenberger](https://arxiv.org/search/cs?searchtype=author&query=Gerstenberger,+R), [Guangyuan Piao](https://arxiv.org/search/cs?searchtype=author&query=Piao,+G), [Nils Blach](https://arxiv.org/search/cs?searchtype=author&query=Blach,+N), [Piotr Nyczyk](https://arxiv.org/search/cs?searchtype=author&query=Nyczyk,+P), [Marcin Copik](https://arxiv.org/search/cs?searchtype=author&query=Copik,+M), [Grzegorz Kwa\u015bniewski](https://arxiv.org/search/cs?searchtype=author&query=Kwa%C5%9Bniewski,+G), [J\u00fcrgen M\u00fcller](https://arxiv.org/search/cs?searchtype=author&query=M%C3%BCller,+J), [Lukas Gianinazzi](https://arxiv.org/search/cs?searchtype=author&query=Gianinazzi,+L), [Ales Kubicek](https://arxiv.org/search/cs?searchtype=author&query=Kubicek,+A), [Hubert Niewiadomski](https://arxiv.org/search/cs?searchtype=author&query=Niewiadomski,+H), [Aidan O'Mahony](https://arxiv.org/search/cs?searchtype=author&query=O'Mahony,+A), [Onur Mutlu](https://arxiv.org/search/cs?searchtype=author&query=Mutlu,+O), [Torsten Hoefler](https://arxiv.org/search/cs?searchtype=author&query=Hoefler,+T)            \n    [View PDF](/pdf/2401.14295)\n    [HTML (experimental)](https://arxiv.org/html/2401.14295v6)\n\n    **\n            Abstract:The field of natural language processing (NLP) has witnessed significant progress in recent years, with a notable focus on improving large language models' (LLM) performance through innovative prompting techniques. Among these, prompt engineering coupled with structures has emerged as a promising paradigm, with designs such as Chain-of-Thought, Tree of Thoughts, or Graph of Thoughts, in which the overall LLM reasoning is guided by a structure such as a graph. As illustrated with numerous examples, this paradigm significantly enhances the LLM's capability to solve numerous tasks, ranging from logical or mathematical reasoning to planning or creative writing. To facilitate the understanding of this growing field and pave the way for future developments, we devise a general blueprint for effective and efficient LLM reasoning schemes. For this, we conduct an in-depth analysis of the prompt execution pipeline, clarifying and clearly defining different concepts. We then build the first taxonomy of structure-enhanced LLM reasoning schemes. We focus on identifying fundamental classes of harnessed structures, and we analyze the representations of the",
+  "metadata": {
+    "title": "[2401.14295] Demystifying Chains, Trees, and Graphs of Thoughts",
+    "author": null,
+    "description": "Abstract page for arXiv paper 2401.14295: Demystifying Chains, Trees, and Graphs of Thoughts",
+    "published": null,
+    "image": "/static/browse/0.3.4/images/arxiv-logo-fb.png",
+    "site": "arXiv.org",
+    "domain": "arxiv.org",
+    "wordCount": 806
+  },
+  "litmus": {
+    "source": {
+      "type": "academic",
+      "authority": 0.85,
+      "rationale": "academic source"
+    },
+    "freshness": {
+      "published": null,
+      "age": "unknown",
+      "stale_warning": "No publish date found \u2014 verify independently",
+      "modified": null,
+      "has_correction": false,
+      "correction_note": null
+    },
+    "tldr": "Abstract page for arXiv paper 2401.14295: Demystifying Chains, Trees, and Graphs of Thoughts",
+    "key_figures": [
+      {
+        "value": "5%",
+        "context": "/search/cs?searchtype=author&query=Kwa%C5%9Bniewski,+G), [J\u00fcrgen M\u00fcller](https://arxiv.org/search/cs?s"
+      },
+      {
+        "value": "3%",
+        "context": "rg/search/cs?searchtype=author&query=M%C3%BCller,+J), [Lukas Gianinazzi](https://arxiv.org/search/cs?s"
+      },
+      {
+        "value": "2,247",
+        "context": "Thu, 25 Jan 2024 16:34:00 UTC (2,247 KB)** **[[v2]](/abs/2401.14295v2) Sat,"
+      },
+      {
+        "value": "2,290",
+        "context": "Sat, 30 Mar 2024 16:33:36 UTC (2,290 KB)** **[[v3]](/abs/2401.14295v3) Fri,"
+      },
+      {
+        "value": "2,297",
+        "context": ") Sat, 8 Feb 2025 09:02:41 UTC (2,297 KB)** **[[v5]](/abs/2401.14295v5) Fri,"
+      }
+    ],
+    "structural_trust_score": {
+      "level": "medium",
+      "trust_factors": [
+        "High-authority source",
+        "No publish date found \u2014 verify independently"
+      ]
+    },
+    "hedge_language": {
+      "density": "low",
+      "markers_found": 0,
+      "per_500_words": 0
+    },
+    "content_density": {
+      "thin_content": false,
+      "substantive_sentence_ratio": 0.7647058823529411
+    },
+    "syndication": {
+      "detected": false,
+      "note": null
+    },
+    "paywall": {
+      "detected": false,
+      "note": null
+    },
+    "content_type": "academic_paper",
+    "reading_time": {
+      "minutes": 4
+    },
+    "is_archived": {
+      "archive_org": true,
+      "archive_is": false
+    },
+    "outbound_authority": {
+      "score": 0.54,
+      "top_domains": [
+        "ui.adsabs.harvard.edu",
+        "scholar.google.com",
+        "api.semanticscholar.org",
+        "info.arxiv.org",
+        "core.ac.uk"
+      ]
+    },
+    "boilerplate_ratio": {
+      "ratio": 0.08,
+      "confidence": "high"
+    }
+  }
+}

package/examples/pay-with-x402.md

@@ -0,0 +1,272 @@
+# Paying for a parse with x402
+
+NanoParse answers an unauthenticated call with **HTTP 402** and machine-readable
+terms — the price, the token, the chain, the recipient, and what a valid signature
+must look like. No account, no API key, no card, no subscription.
+
+- **10 free parses per month with a signed wallet**, or 3 anonymous free tries per
+  network.
+- **After that: $0.002 USDC on Base per parse**, flat.
+- Settlement runs **after** a page is read. A page that cannot be read — bot wall,
+  consent wall, paywall, JS shell with no text — is reported with a named reason
+  and **never charged**.
+
+Every parse returns clean Markdown plus **Litmus** — 20 machine-readable signals
+(source authority, freshness, structural trust, content density, syndication,
+paywall state) in the same response, not as a second billed call.
+
+Two ways to pay. Pick one.
+
+---
+
+## Option A — give the agent a wallet, write no code
+
+Add NanoParse to your MCP client, and give the agent a wallet that can sign:
+
+```json
+{
+  "mcpServers": {
+    "nanoparse": {
+      "url": "https://nanoparse.app/mcp"
+    }
+  }
+}
+```
+
+```
+npx @coinbase/payments-mcp
+```
+
+(The Coinbase agentic wallet MCP — self-custody, funded via Apple Pay. Docs:
+<https://docs.cdp.coinbase.com/agentic-wallet/mcp/welcome>.)
+
+Then the loop is two calls:
+
+1. `nanoparse_fetch(url)`. Once the free tier is spent, the tool returns an
+   `isError` result whose **`structuredContent` is the PaymentRequired object** —
+   `x402Version`, `accepts[]`, `extensions`. It is the quote, not a failure.
+2. Sign `accepts[0]` and retry the same tool with
+   `payment_signature` = the base64url JSON envelope. This argument works in
+   **every** MCP client; there are no custom headers to set. A client that can
+   set headers may instead send the same payload as `Payment-Signature`, or put
+   the envelope object in `_meta["x402/payment"]`.
+
+`nanoparse_status(address)` is free and tells the agent what it needs to know
+before spending: free parses remaining, wallet and USDC balance, whether the next
+call will go through without payment.
+
+---
+
+## Option B — a REST client that pays its own way
+
+~40 lines of Node with [`viem`](https://viem.sh). No SDK, no server-side key:
+the wallet is the caller's.
+
+```js
+// read-page.mjs — read one page, paying $0.002 in USDC on Base only if asked.
+// Usage:  npm i viem && WALLET_KEY=0x... node read-page.mjs https://example.com
+//
+// 1. Try the free tier (10/month with a signed wallet, or 3 anonymous tries): a plain POST.
+// 2. A 402 is the quote, not an error. Read the terms out of it.
+// 3. Sign an EIP-3009 permit over those terms (gas is the facilitator's).
+// 4. Retry with the signed envelope; poll /status (free) until the page lands.
+import { privateKeyToAccount } from "viem/accounts";
+
+const ENDPOINT = "https://nanoparse.app/fetch";
+const account = privateKeyToAccount(process.env.WALLET_KEY);
+const b64 = (o) => Buffer.from(JSON.stringify(o)).toString("base64");
+
+async function readPage(url) {
+  const post = (headers) =>
+    fetch(ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify({ url }),
+    });
+
+  // 1. Free tier first — no payment, no key, no account.
+  let res = await post();
+  if (res.status !== 402) {
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    return poll(await res.json());
+  }
+
+  // 2. The terms. `amount` is micro-USDC ("2000" = $0.002) and `payTo` is the
+  //    only address a permit should ever be signed for.
+  const terms = (await res.json()).payment_required.accepts[0];
+  const now = Math.floor(Date.now() / 1000);
+  const nonce = "0x" + Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("hex");
+  const authorization = {
+    from: account.address,
+    to: terms.payTo,
+    value: terms.amount,
+    validAfter: String(now - 5),
+    validBefore: String(now + 895), // within maxTimeoutSeconds from the challenge
+    nonce,
+  };
+
+  // 3. EIP-3009 transferWithAuthorization. The EIP-712 domain belongs to the
+  //    token contract, so take it from the challenge: extra.name is the domain
+  //    name "USD Coin" — signing against the ticker "USDC" fails verification.
+  const signature = await account.signTypedData({
+    domain: {
+      name: terms.extra.name,
+      version: terms.extra.version,
+      chainId: 8453, // Base
+      verifyingContract: terms.asset,
+    },
+    types: {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" },
+      ],
+    },
+    primaryType: "TransferWithAuthorization",
+    message: {
+      ...authorization,
+      value: BigInt(authorization.value),
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+    },
+  });
+
+  // 4. Retry with the envelope the challenge quoted: accepted[] echoed verbatim.
+  res = await post({
+    "Payment-Signature": b64({ x402Version: 2, accepted: terms, payload: { signature, authorization } }),
+  });
+  const job = await res.json();
+  if (!res.ok) throw new Error(`${job.error_code}: ${job.message}`);
+  return poll(job); // 202 { jobId, statusUrl }
+}
+
+// /status is free and unauthenticated: watch a job without spending anything.
+async function poll(job) {
+  for (;;) {
+    const out = await (await fetch(job.statusUrl)).json();
+    if (out.status === "completed") return out; // { markdown, metadata, litmus }
+    if (out.status !== "processing") throw new Error(`${out.status}: ${out.error_code ?? ""}`);
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+}
+
+console.log((await readPage(process.argv[2])).markdown);
+```
+
+---
+
+## The 402 is the quote
+
+Captured live, free tier exhausted, no payment attached:
+
+```json
+{
+  "error": "payment_required",
+  "error_code": "free_tier_exhausted",
+  "free_calls_used": 10,
+  "free_calls_limit": 10,
+  "payment_required": {
+    "x402Version": 2,
+    "accepts": [
+      {
+        "scheme": "exact",
+        "network": "eip155:8453",
+        "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        "amount": "2000",
+        "payTo": "0x57a1d06873db575baeae1f6af30862a75c7bd570",
+        "maxTimeoutSeconds": 60,
+        "extra": { "assetTransferMethod": "eip3009", "name": "USD Coin", "version": "2" }
+      }
+    ]
+  }
+}
+```
+
+The same terms travel base64url-encoded in the `payment-required` response header,
+and the recipient is repeated as a CAIP-style `pay-to: ethereum:base:0x…` header.
+`access-control-allow-origin: *` and the `Content-Type, Payment-Signature,
+Authorization` request headers are allowed on this route, so a browser-side agent
+can send a signed payment too.
+
+Four fields carry the weight:
+
+- **`amount`** is micro-USDC — `"2000"` is $0.002 at six decimals. There is no
+  currency string to parse.
+- **`network`** is a CAIP-2 chain id (`eip155:8453` is Base) and **`asset`** is the
+  USDC contract on it, so the client never guesses which USDC.
+- **`extra.name` / `extra.version`** are the EIP-712 domain of the token contract:
+  `"USD Coin"` v2. Signing against `"USDC"` produces a signature that fails
+  verification — the domain is part of the digest.
+- **`payTo`** is the only address a permit should ever be signed for. A payload
+  pointing anywhere else is rejected before any signature is checked.
+
+## What the server checks before the facilitator is called
+
+A wrong shape costs nothing — it answers `400 invalid_payment_payload`:
+
+- `x402Version` is exactly `2`.
+- `accepted` repeats the terms verbatim: `scheme`, `network`, `asset`, `amount`,
+  `payTo`.
+- `payload.signature` is `0x` + 130 hex characters (65-byte packed `r‖s‖v`).
+- `payload.authorization.value` equals `amount` exactly.
+- `payload.authorization.nonce` is `0x` + 64 hex characters, and single-use
+  on-chain — which is what makes "retry the same payload" safe rather than hopeful.
+- `validAfter` is in the past and `validBefore` in the future.
+
+## Retry policy, as error codes
+
+| `error_code` | What to do |
+|---|---|
+| `insufficient_usdc` | Fund the wallet and sign a **fresh** envelope. |
+| `invalid_payment_payload`, `invalid_payment` | The shape or signature is wrong. Fix it; retrying unchanged cannot succeed. |
+| `permit_expired`, `permit_not_yet_valid` | Sign a fresh permit. |
+| `settlement_failed` | Ambiguous settle. Retry with the **same** envelope — it is idempotent. |
+| `screening_declined` | Compliance screening declined. Do not retry. |
+| `location_blocked` | A jurisdiction the facilitator does not serve. |
+| `self_send_not_allowed` | Payer and recipient are the same address. |
+| `content_insufficient` | The page rendered but yielded almost no text (JS shell, login wall). **Not charged.** |
+| `domain_blocked` | The host repeatedly returned nothing parseable. **Not charged.** Do not retry. |
+
+There is no refund path because nothing is charged up front: settlement runs after
+a successful read, so a failed render simply never settles.
+
+## Check the recipient before you sign
+
+`/.well-known/x402` publishes the address the endpoint claims, and the 402 repeats
+it. Compare them before signing anything:
+
+```js
+const accept = terms; // accepts[0] from the 402
+const disc = await (await fetch("https://nanoparse.app/.well-known/x402")).json();
+if (!disc.ownershipProofs.map((a) => a.toLowerCase()).includes(accept.payTo.toLowerCase()))
+  throw new Error("recipient not published by the endpoint");
+```
+
+That buys consistency, not identity — both documents come from the same origin —
+but it is one GET and it catches a swapped recipient.
+
+## What was verified
+
+- The client under **Option B** was run verbatim against the live endpoint on
+  2026-10-06 with a fresh, unfunded throwaway wallet: free tier exhausted → `402`
+  → signed envelope → retry → `insufficient_usdc: Payer's USDC balance is too low
+  for this call (needs 2000 micro-USDC on Base)`. The shape and signature were
+  accepted; nothing was charged.
+- The **Option A** MCP loop was verified the same way: `tools/call` returned
+  `isError: true` with `structuredContent` = the PaymentRequired object, and the
+  retry carrying `payment_signature` answered
+  `-32000 / insufficient_usdc` for the unfunded payer.
+- The settle leg — USDC actually moving to the treasury on Base — is exercised
+  end to end by our own labeled canary through this same paid path.
+
+## Docs
+
+- Quick start: <https://nanoparse.app/quickstart>
+- Machine spec: <https://nanoparse.app/openapi.json>
+- Agent-facing description: <https://nanoparse.app/llms.txt>
+- x402 discovery: <https://nanoparse.app/.well-known/x402>
+
+MIT licensed.

package/package.json

@@ -1,20 +1,7 @@
 {
   "name": "nanoparse-mcp",
-  "version": "1.0.9",
-  "description": "MCP client for NanoParse — pay-per-parse web content extraction for AI agents",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "nanoparse-mcp": "dist/index.js"
-  },
-  "files": [
-    "dist/"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "postbuild": "node -e \"var f='dist/index.js';var c=require('fs').readFileSync(f,'utf8');require('fs').writeFileSync(f,'#!/usr/bin/env node\\n'+c);require('fs').chmodSync(f,'755')\"",
-    "prepublishOnly": "npm run build"
-  },
+  "version": "2.0.1",
+  "description": "NanoParse MCP \u2014 hosted Model Context Protocol server for AI agents. Any URL becomes clean Markdown with attribution signals. $0.002 per page via x402, no account or API key.",
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -22,19 +9,28 @@
     "web-scraping",
     "markdown",
     "x402",
-    "ai-agent"
+    "ai-agent",
+    "litmus"
   ],
+  "license": "MIT",
+  "homepage": "https://nanoparse.app",
   "repository": {
     "type": "git",
     "url": "https://github.com/nanoparse-dev/nanoparse-mcp"
   },
-  "license": "MIT",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "viem": "^2.55.8"
+  "bugs": {
+    "url": "https://github.com/nanoparse-dev/nanoparse-mcp/issues"
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "examples/"
+  ],
+  "engines": {
+    "node": ">=18"
   },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.5.0"
+  "publishConfig": {
+    "access": "public"
   }
 }

package/dist/fetch.d.ts

@@ -1,34 +0,0 @@
-interface NanoParseResponse {
-    success: boolean;
-    url: string;
-    markdown: string;
-    metadata: {
-        title?: string;
-        author?: string;
-        description?: string;
-        published?: string;
-        image?: string;
-        favicon?: string;
-        site?: string;
-        domain?: string;
-        wordCount?: number;
-        language?: string;
-    };
-    schemaOrgData?: Record<string, unknown>;
-    freeCallsRemaining?: number;
-    debug?: {
-        contentSelector?: string;
-        metadataSource?: string;
-        cleaning?: {
-            blocksRemoved: number;
-            blocksKept: number;
-        };
-        timing?: {
-            metadataFetchMs: number;
-            browserRenderMs: number;
-        };
-    };
-}
-export declare function fetchPage(url: string, debug?: boolean): Promise<NanoParseResponse>;
-export {};
-//# sourceMappingURL=fetch.d.ts.map

package/dist/fetch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../src/fetch.ts"],"names":[],"mappings":"AAeA,UAAU,iBAAiB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE;QACN,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,EAAE;YAAE,aAAa,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,CAAC;QACzD,MAAM,CAAC,EAAE;YAAE,eAAe,EAAE,MAAM,CAAC;YAAC,eAAe,EAAE,MAAM,CAAA;SAAE,CAAC;KAC/D,CAAC;CACH;AAED,wBAAsB,SAAS,CAC7B,GAAG,EAAE,MAAM,EACX,KAAK,UAAQ,GACZ,OAAO,CAAC,iBAAiB,CAAC,CA2C5B"}

package/dist/fetch.js

@@ -1,37 +0,0 @@
-import { signPayment } from "./payment.js";
-const FETCH_ENDPOINT = "https://nanoparse.app/fetch";
-export async function fetchPage(url, debug = false) {
-    const body = { url };
-    if (debug)
-        body.debug = true;
-    // First attempt — may return 402 if payment is required
-    let res = await fetch(FETCH_ENDPOINT, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-    });
-    // Handle x402 payment flow
-    if (res.status === 402) {
-        const paymentTerms = await res.json();
-        if (paymentTerms.error !== "payment_required") {
-            throw new Error(`Unexpected 402 response: ${JSON.stringify(paymentTerms)}`);
-        }
-        const signature = await signPayment(paymentTerms);
-        // Retry with payment signature
-        res = await fetch(FETCH_ENDPOINT, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "Payment-Signature": signature,
-            },
-            body: JSON.stringify(body),
-        });
-    }
-    if (!res.ok) {
-        const errorText = await res.text().catch(() => "Unknown error");
-        throw new Error(`NanoParse API returned ${res.status}: ${errorText}`);
-    }
-    const data = await res.json();
-    return data;
-}
-//# sourceMappingURL=fetch.js.map

package/dist/fetch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetch.js","sourceRoot":"","sources":["../src/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,cAAc,GAAG,6BAA6B,CAAC;AAuCrD,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,GAAW,EACX,KAAK,GAAG,KAAK;IAEb,MAAM,IAAI,GAA4B,EAAE,GAAG,EAAE,CAAC;IAC9C,IAAI,KAAK;QAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IAE7B,wDAAwD;IACxD,IAAI,GAAG,GAAG,MAAM,KAAK,CAAC,cAAc,EAAE;QACpC,MAAM,EAAE,MAAM;QACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;QAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;KAC3B,CAAC,CAAC;IAEH,2BAA2B;IAC3B,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;QACvB,MAAM,YAAY,GAAqB,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;QAExD,IAAI,YAAY,CAAC,KAAK,KAAK,kBAAkB,EAAE,CAAC;YAC9C,MAAM,IAAI,KAAK,CACb,4BAA4B,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,CAC3D,CAAC;QACJ,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,WAAW,CAAC,YAAY,CAAC,CAAC;QAElD,+BAA+B;QAC/B,GAAG,GAAG,MAAM,KAAK,CAAC,cAAc,EAAE;YAChC,MAAM,EAAE,MAAM;YACd,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,mBAAmB,EAAE,SAAS;aAC/B;YACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SAC3B,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QACZ,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,CAAC;QAChE,MAAM,IAAI,KAAK,CACb,0BAA0B,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE,CACrD,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAsB,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;IACjD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -1,80 +0,0 @@
-#!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { fetchPage } from "./fetch.js";
-const server = new Server({
-    name: "nanoparse-mcp",
-    version: "1.0.9",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-        {
-            name: "nanoparse_fetch",
-            description: "Fetch a web page and return clean, structured Markdown with metadata. " +
-                "First 10 parses free per device. After that, pay $0.01 USDC on Base via x402. " +
-                "No account or API key required.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    url: {
-                        type: "string",
-                        description: "The URL to fetch and convert to Markdown",
-                    },
-                    debug: {
-                        type: "boolean",
-                        description: "If true, include extraction diagnostics in the response (contentSelector, metadataSource, cleaning stats, timing)",
-                        default: false,
-                    },
-                },
-                required: ["url"],
-            },
-        },
-    ],
-}));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    if (request.params.name !== "nanoparse_fetch") {
-        throw new Error(`Unknown tool: ${request.params.name}`);
-    }
-    const args = request.params.arguments;
-    if (!args.url || typeof args.url !== "string") {
-        throw new Error('Missing required parameter: "url"');
-    }
-    try {
-        const result = await fetchPage(args.url, args.debug ?? false);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: result.markdown,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `NanoParse error: ${message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-});
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-}
-main().catch((err) => {
-    console.error("nanoparse-mcp server failed to start:", String(err));
-    process.exit(1);
-});
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,MAAM,GAAG,IAAI,MAAM,CACvB;IACE,IAAI,EAAE,eAAe;IACrB,OAAO,EAAE,OAAO;CACjB,EACD;IACE,YAAY,EAAE;QACZ,KAAK,EAAE,EAAE;KACV;CACF,CACF,CAAC;AAEF,MAAM,CAAC,iBAAiB,CAAC,sBAAsB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;IAC5D,KAAK,EAAE;QACL;YACE,IAAI,EAAE,iBAAiB;YACvB,WAAW,EACT,wEAAwE;gBACxE,gFAAgF;gBAChF,iCAAiC;YACnC,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,GAAG,EAAE;wBACH,IAAI,EAAE,QAAQ;wBACd,WAAW,EAAE,0CAA0C;qBACxD;oBACD,KAAK,EAAE;wBACL,IAAI,EAAE,SAAS;wBACf,WAAW,EACT,mHAAmH;wBACrH,OAAO,EAAE,KAAK;qBACf;iBACF;gBACD,QAAQ,EAAE,CAAC,KAAK,CAAC;aAClB;SACF;KACF;CACF,CAAC,CAAC,CAAC;AAEJ,MAAM,CAAC,iBAAiB,CAAC,qBAAqB,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;IAChE,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,iBAAiB,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,SAG3B,CAAC;IAEF,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,OAAO,IAAI,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACvD,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC;QAE9D,OAAO;YACL,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,MAAM,CAAC,QAAQ;iBACtB;aACF;YACD,iBAAiB,EAAE,MAAM;SAC1B,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjE,OAAO;YACL,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,oBAAoB,OAAO,EAAE;iBACpC;aACF;YACD,OAAO,EAAE,IAAI;SACd,CAAC;IACJ,CAAC;AACH,CAAC,CAAC,CAAC;AAEH,KAAK,UAAU,IAAI;IACjB,MAAM,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAClC,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,KAAK,CAAC,uCAAuC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IACpE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/payment.d.ts

@@ -1,30 +0,0 @@
-/**
- * Payment terms returned by NanoParse in a 402 response body.
- * These are the fields the client must sign before retrying.
- */
-interface X402PaymentTerms {
-    error: "payment_required";
-    scheme: "exact";
-    network: string;
-    asset: string;
-    amount: string;
-    payTo: string;
-    free_calls_used: number;
-    free_calls_limit: number;
-}
-/**
- * Sign x402 payment terms using the wallet key and return the
- * signature for the Payment-Signature header.
- *
- * The signature is created by signing a JSON-serialized
- * representation of the payment terms with the wallet's private key.
- * The x402 facilitator at x402.org verifies and settles the
- * transaction — the client never constructs raw blockchain
- * transactions directly.
- *
- * The wallet key is read from NANOPARSE_WALLET_KEY and is never
- * logged, printed, or included in error output.
- */
-export declare function signPayment(paymentTerms: X402PaymentTerms): Promise<string>;
-export {};
-//# sourceMappingURL=payment.d.ts.map

package/dist/payment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payment.d.ts","sourceRoot":"","sources":["../src/payment.ts"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,UAAU,gBAAgB;IACxB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAC/B,YAAY,EAAE,gBAAgB,GAC7B,OAAO,CAAC,MAAM,CAAC,CA6BjB"}

package/dist/payment.js

@@ -1,51 +0,0 @@
-import { privateKeyToAccount } from "viem/accounts";
-import { createWalletClient, http } from "viem";
-import { base } from "viem/chains";
-function getWalletKey() {
-    const key = process.env.NANOPARSE_WALLET_KEY;
-    if (!key) {
-        throw new Error("NANOPARSE_WALLET_KEY environment variable is not set. " +
-            "Copy .env.example to .env and add your Base wallet private key.");
-    }
-    if (!key.startsWith("0x")) {
-        return `0x${key}`;
-    }
-    return key;
-}
-/**
- * Sign x402 payment terms using the wallet key and return the
- * signature for the Payment-Signature header.
- *
- * The signature is created by signing a JSON-serialized
- * representation of the payment terms with the wallet's private key.
- * The x402 facilitator at x402.org verifies and settles the
- * transaction — the client never constructs raw blockchain
- * transactions directly.
- *
- * The wallet key is read from NANOPARSE_WALLET_KEY and is never
- * logged, printed, or included in error output.
- */
-export async function signPayment(paymentTerms) {
-    const key = getWalletKey();
-    const account = privateKeyToAccount(key);
-    const client = createWalletClient({
-        account,
-        chain: base,
-        transport: http(),
-    });
-    // Serialize the payment terms deterministically for signing.
-    // The x402 facilitator expects a JSON payload with sorted keys.
-    const payload = JSON.stringify({
-        scheme: paymentTerms.scheme,
-        network: paymentTerms.network,
-        asset: paymentTerms.asset,
-        amount: paymentTerms.amount,
-        payTo: paymentTerms.payTo,
-    }, Object.keys(paymentTerms).sort());
-    const signature = await client.signMessage({
-        account,
-        message: payload,
-    });
-    return signature;
-}
-//# sourceMappingURL=payment.js.map

package/dist/payment.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"payment.js","sourceRoot":"","sources":["../src/payment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAY,MAAM,MAAM,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,SAAS,YAAY;IACnB,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;IAC7C,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CACb,wDAAwD;YACtD,iEAAiE,CACpE,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,GAAG,EAAS,CAAC;IAC3B,CAAC;IACD,OAAO,GAAU,CAAC;AACpB,CAAC;AAiBD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,YAA8B;IAE9B,MAAM,GAAG,GAAG,YAAY,EAAE,CAAC;IAC3B,MAAM,OAAO,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAC;IAEzC,MAAM,MAAM,GAAG,kBAAkB,CAAC;QAChC,OAAO;QACP,KAAK,EAAE,IAAI;QACX,SAAS,EAAE,IAAI,EAAE;KAClB,CAAC,CAAC;IAEH,6DAA6D;IAC7D,gEAAgE;IAChE,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAC5B;QACE,MAAM,EAAE,YAAY,CAAC,MAAM;QAC3B,OAAO,EAAE,YAAY,CAAC,OAAO;QAC7B,KAAK,EAAE,YAAY,CAAC,KAAK;QACzB,MAAM,EAAE,YAAY,CAAC,MAAM;QAC3B,KAAK,EAAE,YAAY,CAAC,KAAK;KAC1B,EACD,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI,EAAE,CACjC,CAAC;IAEF,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC;QACzC,OAAO;QACP,OAAO,EAAE,OAAO;KACjB,CAAC,CAAC;IAEH,OAAO,SAAS,CAAC;AACnB,CAAC"}