agentmint-hermes-runner 0.4.0__tar.gz

agentmint_hermes_runner-0.4.0/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: pytest -v

agentmint_hermes_runner-0.4.0/.github/workflows/release.yml

@@ -0,0 +1,20 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

agentmint_hermes_runner-0.4.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.pytest_cache/
+.ruff_cache/
+.venv/
+venv/
+.env
+.DS_Store

agentmint_hermes_runner-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentMint
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentmint_hermes_runner-0.4.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: agentmint-hermes-runner
+Version: 0.4.0
+Summary: Route Hermes delegate_task(background=True) to named, persistent AgentMint subagents.
+Project-URL: Homepage, https://github.com/mesutcelik/agentmint-hermes
+Project-URL: Repository, https://github.com/mesutcelik/agentmint-hermes
+Project-URL: Issues, https://github.com/mesutcelik/agentmint-hermes/issues
+Author: AgentMint
+License: MIT
+License-File: LICENSE
+Keywords: agentmint,ai-agents,delegation,hermes,mpp,stripe-link,subagents,tempo
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agentmint-hermes-runner
+
+Route Hermes `delegate_task(background=True)` to named, persistent AgentMint subagents.
+
+> Positioning + full quickstart in [`agentmint-hermes/SKILL.md`](agentmint-hermes/SKILL.md).
+
+## Status
+
+**v0.4.0** — alpha. Auth backends: `BearerAuth` (Stripe-Link), `TempoAuth` (Tempo USDC.e). Polling-only delivery. Hermes feature coverage matrix in [`agentmint-hermes/SKILL.md`](agentmint-hermes/SKILL.md).
+
+## Install in Hermes
+
+```bash
+hermes skills install mesutcelik/agentmint-hermes/agentmint-hermes
+```
+
+(The third segment is the skill subfolder inside the repo, per Hermes' `GitHubSource` convention.)
+
+## Three-line Hermes wiring (Strategy B)
+
+```python
+import os
+from agentmint_hermes_runner import (
+    AgentMintDispatcher, BearerAuth, install_delegate_task_wrapper,
+)
+
+dispatcher = AgentMintDispatcher(auth=BearerAuth(jwt=os.environ["AGENTMINT_JWT"]))
+install_delegate_task_wrapper(dispatcher, default_agent_name="default-worker")
+```
+
+Every `delegate_task(background=True)` inside Hermes now routes to AgentMint's `default-worker` subagent. Its `/workspace/MEMORY.md` accumulates across every delegation. No HTTPS, no ngrok, no webhook secret — a daemon thread polls `agent.run.status` (free, Bearer-only) every 5 s and pushes completions onto Hermes' `completion_queue` directly. Server-side requires AgentMint API ≥ 0.7.0 for the polling endpoint.
+
+## Install
+
+```bash
+pip install agentmint-hermes-runner
+```
+
+## Surface
+
+```python
+from agentmint_hermes_runner import (
+    AgentMintDispatcher,
+    AgentMintWebhookReceiver,
+    BearerAuth, TempoAuth,
+    Task,
+)
+
+dispatcher = AgentMintDispatcher(
+    auth=BearerAuth(jwt=os.environ["AGENTMINT_JWT"]),
+    webhook_url="https://my-gateway.example.com/agentmint-webhook",  # optional
+)
+
+# Single dispatch (Hermes delegate_task analog):
+result = dispatcher.dispatch(
+    agent_name="reviewer-myrepo",
+    goal="Review the diff in /workspace/pr-42 and flag risks.",
+    context="Project at /workspace, Python 3.11, uses Flask + PyJWT.",
+    toolsets=["terminal", "file"],   # "web" raises UnsupportedToolset in v0.2
+    role="leaf",                      # or "orchestrator"
+    max_iterations=50,
+    child_timeout_seconds=600,        # floor 30s; fires agent.cancel on expiry
+)
+
+# Batch dispatch (Hermes tasks=[…] analog):
+results = dispatcher.dispatch_batch(
+    tasks=[
+        Task(agent_name="researcher-wasm", goal="WASM 2026 survey", context="…"),
+        Task(agent_name="researcher-riscv", goal="RISC-V 2026 survey", context="…"),
+    ],
+    max_concurrent_children=3,
+    child_timeout_seconds=900,
+)
+# results in input order; failed/timeout/interrupted statuses returned in-band
+```
+
+## Test
+
+```bash
+pip install -e ".[dev]"
+pytest
+ruff check .
+```
+
+## Known unsupported (v0.2)
+
+- **`toolsets=["web"]`** — no canonical AgentMint web-fetch skill yet. The supported harnesses (claude-code / codex / opencode) all have built-in web access via the harness itself, but we don't expose a Hermes-symmetric toolset for it. Raises `UnsupportedToolset` at compose time so the gap is loud, not silent.
+- **`max_spawn_depth`** — AgentMint sandboxes aren't structurally bounded by depth.
+
+## License
+
+MIT

agentmint_hermes_runner-0.4.0/README.md

@@ -0,0 +1,92 @@
+# agentmint-hermes-runner
+
+Route Hermes `delegate_task(background=True)` to named, persistent AgentMint subagents.
+
+> Positioning + full quickstart in [`agentmint-hermes/SKILL.md`](agentmint-hermes/SKILL.md).
+
+## Status
+
+**v0.4.0** — alpha. Auth backends: `BearerAuth` (Stripe-Link), `TempoAuth` (Tempo USDC.e). Polling-only delivery. Hermes feature coverage matrix in [`agentmint-hermes/SKILL.md`](agentmint-hermes/SKILL.md).
+
+## Install in Hermes
+
+```bash
+hermes skills install mesutcelik/agentmint-hermes/agentmint-hermes
+```
+
+(The third segment is the skill subfolder inside the repo, per Hermes' `GitHubSource` convention.)
+
+## Three-line Hermes wiring (Strategy B)
+
+```python
+import os
+from agentmint_hermes_runner import (
+    AgentMintDispatcher, BearerAuth, install_delegate_task_wrapper,
+)
+
+dispatcher = AgentMintDispatcher(auth=BearerAuth(jwt=os.environ["AGENTMINT_JWT"]))
+install_delegate_task_wrapper(dispatcher, default_agent_name="default-worker")
+```
+
+Every `delegate_task(background=True)` inside Hermes now routes to AgentMint's `default-worker` subagent. Its `/workspace/MEMORY.md` accumulates across every delegation. No HTTPS, no ngrok, no webhook secret — a daemon thread polls `agent.run.status` (free, Bearer-only) every 5 s and pushes completions onto Hermes' `completion_queue` directly. Server-side requires AgentMint API ≥ 0.7.0 for the polling endpoint.
+
+## Install
+
+```bash
+pip install agentmint-hermes-runner
+```
+
+## Surface
+
+```python
+from agentmint_hermes_runner import (
+    AgentMintDispatcher,
+    AgentMintWebhookReceiver,
+    BearerAuth, TempoAuth,
+    Task,
+)
+
+dispatcher = AgentMintDispatcher(
+    auth=BearerAuth(jwt=os.environ["AGENTMINT_JWT"]),
+    webhook_url="https://my-gateway.example.com/agentmint-webhook",  # optional
+)
+
+# Single dispatch (Hermes delegate_task analog):
+result = dispatcher.dispatch(
+    agent_name="reviewer-myrepo",
+    goal="Review the diff in /workspace/pr-42 and flag risks.",
+    context="Project at /workspace, Python 3.11, uses Flask + PyJWT.",
+    toolsets=["terminal", "file"],   # "web" raises UnsupportedToolset in v0.2
+    role="leaf",                      # or "orchestrator"
+    max_iterations=50,
+    child_timeout_seconds=600,        # floor 30s; fires agent.cancel on expiry
+)
+
+# Batch dispatch (Hermes tasks=[…] analog):
+results = dispatcher.dispatch_batch(
+    tasks=[
+        Task(agent_name="researcher-wasm", goal="WASM 2026 survey", context="…"),
+        Task(agent_name="researcher-riscv", goal="RISC-V 2026 survey", context="…"),
+    ],
+    max_concurrent_children=3,
+    child_timeout_seconds=900,
+)
+# results in input order; failed/timeout/interrupted statuses returned in-band
+```
+
+## Test
+
+```bash
+pip install -e ".[dev]"
+pytest
+ruff check .
+```
+
+## Known unsupported (v0.2)
+
+- **`toolsets=["web"]`** — no canonical AgentMint web-fetch skill yet. The supported harnesses (claude-code / codex / opencode) all have built-in web access via the harness itself, but we don't expose a Hermes-symmetric toolset for it. Raises `UnsupportedToolset` at compose time so the gap is loud, not silent.
+- **`max_spawn_depth`** — AgentMint sandboxes aren't structurally bounded by depth.
+
+## License
+
+MIT

agentmint_hermes_runner-0.4.0/agentmint-hermes/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: agentmint-hermes
+description: Mint AgentMint pay-as-you-go subagents from Hermes. Provisions a persistent sandbox (Claude Code / Codex / OpenCode harness, any model via OpenRouter) for a long-running task; subsequent `delegate_task(background=true)` calls dispatch to it, hibernate the box between calls, and bill per run. Pay via Stripe-Link (link-cli) or Tempo USDC.e.
+version: 0.2.0
+author: AgentMint
+license: MIT
+platforms: [linux, macos]
+metadata:
+  hermes:
+    tags: [Subagents, Delegation, Payments, MPP, Sandbox]
+    related_skills: [mpp-agent, stripe-link-cli]
+---
+
+# AgentMint × Hermes
+
+Long-lived, named, USDC-paid subagents that Hermes can `delegate_task` against. Each subagent has its own bounded sandbox (Upstash Box), its own filesystem that persists across calls (`/workspace/MEMORY.md` is the standard memory anchor), and a stable name (`reviewer-myrepo`, `support-acme`, …). Hibernates to zero between calls — billed only when running.
+
+## When to use
+
+- Hermes' main session needs a **specialist** (PR reviewer, compliance checker, customer-support agent, codebase oracle, etc.) that accumulates domain knowledge across days/weeks.
+- A task naturally **fans out** into N independent slices and you want each one on its own sandbox.
+- You want **`delegate_task(background=true)`** to dispatch the actual work somewhere with isolated credentials, not the Hermes gateway itself.
+- You want to use a **specific harness × model** combination (e.g. opencode + `openrouter/fusion`, claude-code + claude-sonnet-4-6) without baking those choices into Hermes.
+
+Not the right tool when:
+- The task is one-shot and Hermes can answer directly.
+- You need cross-subagent shared state (each subagent's MEMORY is its own).
+
+## Two integration tiers
+
+### Tier 1 — Direct (no Python, no Hermes code changes)
+
+Hermes calls AgentMint's JSON-RPC `/a2a` endpoint via `terminal` using whichever wallet skill the user has authenticated. Mint once, run many times.
+
+### Tier 2 — `delegate_task` background dispatch
+
+Pip-install `agentmint-hermes-runner` and wire it into Hermes' gateway. After that, `delegate_task(background=True, …)` results route through PR #40946's async-delegation rail (merged 2026-06-15). Hermes' existing `_async_delegation_watcher` re-injects the result as a new turn in the originating session.
+
+## Wallet matrix
+
+AgentMint speaks the same `/a2a` endpoint for both wallets — pick whichever Hermes already has authenticated.
+
+| Wallet | When | Path |
+|---|---|---|
+| **Stripe-Link** (`link-cli`) | User has a card, no crypto wallet. Best for non-developers. | Bearer JWT against a caller-wide credit wallet — bootstrap once, debits per call |
+| **Tempo Wallet** | User has Tempo wallet authenticated; wants spend controls + service discovery | Per-call x402/MPP, USDC.e on Tempo (`eip155:4217`) |
+
+Fetch the underlying wallet skill via `web_extract` before invoking, so its setup steps are in context:
+
+- `https://agentmint.store/SKILL.md` — full AgentMint API (every method, every rail)
+- Hermes' built-in `stripe-link-cli` skill for `link-cli`
+- Hermes' built-in `mpp-agent` skill for `tempo request`
+
+## Tier 1 — Direct mint + run
+
+### Path A: Stripe-Link (link-cli + credit wallet)
+
+Bootstrap once, then every subsequent `agent.*` call is Bearer-paid against a shared credit wallet — no Stripe per-call fee.
+
+```bash
+# 1) Bootstrap the wallet (min $10) — via the stripe-link-cli skill
+link-cli mpp pay https://api.agentmint.store/a2a \
+  -X POST -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"credits.topup","params":{"amount_usd":10}}' \
+  --spend-request-id <lsrq_…>
+# → response.access_token = <jwt>   (caller-wide; works for any subagent)
+
+# 2) Mint a subagent (Bearer-paid, 0.10 USDC equivalent debited from wallet)
+curl -X POST https://api.agentmint.store/a2a \
+  -H 'Authorization: Bearer <jwt>' -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"agent.create","params":{"name":"reviewer-myrepo"}}'
+
+# 3) Run the subagent (per-call price debited from the same wallet)
+curl -X POST https://api.agentmint.store/a2a \
+  -H 'Authorization: Bearer <jwt>' -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"agent.run","params":{"name":"reviewer-myrepo","prompt":"…"}}'
+
+# 4) Check the shared balance any time
+curl -X POST https://api.agentmint.store/a2a \
+  -H 'Authorization: Bearer <jwt>' -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"credits.balance","params":{}}'
+```
+
+Same JWT works across every subagent the user mints — one balance, N subagents.
+
+### Path B: Tempo Wallet
+
+```bash
+tempo wallet login           # one-time, browser-based
+tempo wallet whoami          # confirms address + USDC balance
+
+tempo request -X POST \
+  --json '{"jsonrpc":"2.0","id":1,"method":"agent.create","params":{"name":"reviewer-myrepo"}}' \
+  https://api.agentmint.store/a2a
+```
+
+Pin to `tempo-request@0.5.2` — newer versions hit "Invalid base64 JSON header" against AgentMint's challenge. Downgrade with `tempo cli 0.0.0 downgrade tempo request cli to 0.5.2`.
+
+## Tier 2 — `delegate_task(background=True)` dispatch (Strategy B)
+
+`install_delegate_task_wrapper` monkey-patches `tools.async_delegation.dispatch_async_delegation` (the PR #40946 hook) so every `delegate_task(background=True, single-task)` call inside Hermes transparently routes to a named, persistent AgentMint subagent. Sync `delegate_task` and batch `delegate_task` are untouched.
+
+Completion is delivered via **polling** against AgentMint's `agent.run.status` endpoint (Bearer-only, free). A daemon thread per dispatch polls every 5 s and pushes completions onto Hermes' `completion_queue` via `_push_completion_event`. No public HTTPS endpoint, no webhook secret, no HTTP route to register — polling is the only delivery mode.
+
+### Step-by-step setup
+
+**Step 1 — Bootstrap an AgentMint wallet (one-time)**
+
+```bash
+# Stripe-Link (recommended, supports polling) — min $10:
+link-cli mpp pay https://api.agentmint.store/a2a \
+  -X POST -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"credits.topup","params":{"amount_usd":10}}'
+# → response.result.access_token = <JWT>
+
+export AGENTMINT_JWT=<the JWT>
+```
+
+(Tempo path also works, but polling is Bearer-only — Tempo users must use webhook mode, covered in "Webhook mode" below.)
+
+**Step 2 — Pre-mint the subagent (one-time)**
+
+```bash
+curl -X POST https://api.agentmint.store/a2a \
+  -H "Authorization: Bearer $AGENTMINT_JWT" \
+  -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"agent.create","params":{
+        "name":"default-worker",
+        "harness":"opencode",
+        "model":"openrouter/fusion"}}'
+```
+
+This is the entity that will REMEMBER across every Hermes delegation. Its `/workspace/MEMORY.md` accumulates context across every call. Cost: 0.10 USDC equivalent debited from the credit wallet.
+
+**Step 3 — Install the Python adapter in Hermes' venv**
+
+```bash
+pip install agentmint-hermes-runner
+```
+
+Verify: `python -c "import agentmint_hermes_runner; print(agentmint_hermes_runner.__version__)"` → `0.3.0` or higher.
+
+**Step 4 — Add three lines to your Hermes gateway startup**
+
+Put this in your Hermes gateway entry-point (or wherever you instantiate the gateway), BEFORE any `delegate_task(background=True)` call:
+
+```python
+import os
+from agentmint_hermes_runner import (
+    AgentMintDispatcher, BearerAuth, install_delegate_task_wrapper,
+)
+
+dispatcher = AgentMintDispatcher(auth=BearerAuth(jwt=os.environ["AGENTMINT_JWT"]))
+install_delegate_task_wrapper(dispatcher, default_agent_name="default-worker")
+```
+
+That's the entire wiring. The function returns an `uninstall()` callable if you want to undo it later (mostly useful in tests).
+
+**Step 5 — Restart Hermes and test**
+
+Restart the gateway so the new module loads and the patch is in effect. Then from inside a Hermes session:
+
+```
+> use delegate_task with background=true to ask: "Say hello and tell me what
+  you remember from prior calls."
+```
+
+The LLM will call `delegate_task(background=True, goal="…")`. Behind the scenes:
+1. Adapter calls `agent.run` on AgentMint with `async: true`
+2. AgentMint returns a `run_id` (e.g. `arun_a1b2c3d4`)
+3. Adapter spawns a daemon thread that polls `agent.run.status` every 5 s
+4. AgentMint finishes the run (~15-60 s typically)
+5. Adapter calls `_push_completion_event` → Hermes' `completion_queue`
+6. Hermes' `_async_delegation_watcher` drains and re-injects the result as a new turn
+
+**Step 6 — Verify persistence (the value proposition)**
+
+Call `delegate_task(background=true)` twice with different goals against the same Hermes session. The second response should reference details from the first — because `/workspace/MEMORY.md` survived between dispatches. That's the differentiator from Hermes' native `delegate_task` (which always starts fresh).
+
+
+## Hermes `delegate_task` coverage (v0.3)
+
+| Hermes feature | AgentMint via this runner | Notes |
+|---|---|---|
+| `goal` | ✅ Concatenated under `## Goal` | `dispatcher.dispatch(goal=…)` |
+| `context` | ✅ Concatenated under `## Context` | Client-side concat — no server-side `context` field |
+| `toolsets=["terminal", "file"]` restrictions | ✅ Soft hints in prompt ("Do not run shell commands.", …) | Sandbox can't structurally enforce; the harness should respect the hint |
+| `toolsets=["web"]` | ❌ **Unsupported** — raises `UnsupportedToolset` | No canonical web-fetch skill in the AgentMint catalog yet; tracked separately |
+| `role="leaf"` / `"orchestrator"` | ✅ Soft hint in prompt | Default `"leaf"` |
+| `max_iterations` | ✅ Soft hint ("Soft iteration budget: ~N actions.") | Harness-dependent enforcement |
+| `tasks=[{…}, {…}]` (batch) | ✅ `dispatcher.dispatch_batch(tasks=…)` — parallel via ThreadPoolExecutor, results in input order | Each Task targets a named subagent |
+| `max_concurrent_children` | ✅ `max_concurrent_children=N` param to `dispatch_batch` | Default 3 |
+| `child_timeout_seconds` | ✅ `child_timeout_seconds=N` param; floor 30s; fires `agent.cancel` on expiry | Single + batch |
+| Interrupt cascade | ✅ `cancel_event=threading.Event` to `dispatch_batch` — fires `agent.cancel` on all in-flight | |
+| `background=True` (PR #40946) | ✅ **`install_delegate_task_wrapper(...)` — Strategy B, polling** | Transparent to the LLM; polling-only |
+| Result ordering (by task index) | ✅ `dispatch_batch` returns in input order regardless of completion order | |
+| `max_spawn_depth` (nested delegation) | n/a | AgentMint sandboxes aren't depth-bounded structurally |
+| `/agents` TUI overlay | n/a | Pure Hermes UI feature; use `dispatcher.list()` to enumerate subagents |
+| Credential inheritance | **better** | Each subagent has its own credentials (no parent key sharing) |
+| "Fresh conversation per call" | **inverted** | AgentMint subagents persist `/workspace/MEMORY.md` across calls — this is the core value |
+
+## Pitfalls
+
+- **Mode 1 (Stripe-Link) and Mode 2 (Tempo) don't share state.** Funds in the credit wallet (`account:<principal>`) are not transferable to a blockchain address and vice versa. Pick one model per principal.
+- **JWT is caller-wide on Stripe-Link.** One token authorises any agent.* call against any subagent the principal owns. If lost, re-bootstrap via `credits.topup` with no Bearer — the server rotates the canonical jti. The old token is NOT auto-revoked; revoke it explicitly via `credits.revoke_token --jti <jti>` if you know the lost jti.
+- **`name` is global + immutable.** First mint wins. Pick something specific enough to avoid collisions (`reviewer-mesutcelik-agentmint`, not `reviewer`). Released only by `agent.delete`.
+- **Stripe-MPP only accepts `credits.topup`.** Trying `agent.create` over Stripe-MPP returns `400 use_bearer_after_topup`. Bootstrap with `credits.topup` first.
+- **Tempo broadcast is client-side.** `tempo request` broadcasts before AgentMint's server sees the payment, so a server-side failure after `verify` still leaves the customer charged. Grep server logs for `[agentmint/refund-needed]` for manual operator refund triggers.
+- **Wallet keys never enter Hermes context.** Both wallet skills store credentials under their own config dirs; never `cat`/`read_file` them.
+
+## Verification
+
+```bash
+# Confirm the AgentMint endpoint is reachable + supports your wallet
+curl -X POST https://api.agentmint.store/a2a \
+  -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"agent.create","params":{}}'
+# → 402 with accepts[] enumerating supported chains. Pick the one matching your wallet.
+```
+
+For Tier 2, the canary is a complete dispatch + webhook + re-injection cycle. See `examples/stripe_link.py` and `examples/tempo_wallet.py` in the agentmint-hermes repo.

agentmint_hermes_runner-0.4.0/examples/hermes_strategy_b.py

@@ -0,0 +1,51 @@
+"""Strategy B: wire AgentMint into Hermes so `delegate_task(background=True)`
+transparently routes to a persistent AgentMint subagent.
+
+Prerequisites:
+    1. Bootstrap an AgentMint credit wallet via link-cli (one-time, $10 min):
+       link-cli mpp pay https://api.agentmint.store/a2a -X POST \\
+         -H 'Content-Type: application/json' \\
+         -d '{"jsonrpc":"2.0","id":1,"method":"credits.topup","params":{"amount_usd":10}}'
+       export AGENTMINT_JWT=<the access_token from the response>
+
+    2. Pre-mint your subagent (this is the entity that will REMEMBER across
+       every Hermes delegation):
+       curl -X POST https://api.agentmint.store/a2a \\
+         -H "Authorization: Bearer $AGENTMINT_JWT" \\
+         -H 'Content-Type: application/json' \\
+         -d '{"jsonrpc":"2.0","id":1,"method":"agent.create",
+              "params":{"name":"default-worker","harness":"opencode",
+                        "model":"openrouter/fusion"}}'
+
+    3. pip install agentmint-hermes-runner inside Hermes' virtualenv.
+
+Drop this snippet into your Hermes gateway startup code (before any
+delegate_task call). That's the entire wiring — no HTTPS endpoint, no
+webhook secret, no HTTP route.
+"""
+import os
+
+from agentmint_hermes_runner import (
+    AgentMintDispatcher,
+    BearerAuth,
+    install_delegate_task_wrapper,
+)
+
+
+def main() -> None:
+    dispatcher = AgentMintDispatcher(
+        auth=BearerAuth(jwt=os.environ["AGENTMINT_JWT"]),
+    )
+
+    install_delegate_task_wrapper(
+        dispatcher=dispatcher,
+        default_agent_name="default-worker",
+        poll_interval=5.0,
+    )
+    # From here on, every delegate_task(background=True) call inside Hermes
+    # routes to the AgentMint subagent named "default-worker". Its
+    # /workspace/MEMORY.md accumulates context across every delegation.
+
+
+if __name__ == "__main__":
+    main()

agentmint_hermes_runner-0.4.0/examples/stripe_link.py

@@ -0,0 +1,38 @@
+"""Dispatch a generic 'hello' goal to a named AgentMint subagent via Stripe-Link.
+
+Prerequisites:
+    1. Bootstrap a credit wallet via link-cli (one-time, min $10):
+       link-cli mpp pay https://api.agentmint.store/a2a \\
+         -X POST -H 'Content-Type: application/json' \\
+         -d '{"jsonrpc":"2.0","id":1,"method":"credits.topup","params":{"amount_usd":10}}'
+       The response includes `result.access_token` — the wallet JWT.
+
+    2. export AGENTMINT_JWT=<the jwt>
+    3. Pre-mint a subagent once (or call dispatcher.create() in code):
+       agentmint agent create --name hello-bot
+    4. export AGENT_NAME=hello-bot
+
+Run:
+    python examples/stripe_link.py
+"""
+import os
+
+from agentmint_hermes_runner import AgentMintDispatcher, BearerAuth
+
+
+def main() -> None:
+    dispatcher = AgentMintDispatcher(
+        endpoint=os.environ.get("AGENTMINT_ENDPOINT", "https://api.agentmint.store/a2a"),
+        auth=BearerAuth(jwt=os.environ["AGENTMINT_JWT"]),
+    )
+
+    agent_name = os.environ["AGENT_NAME"]
+    result = dispatcher.dispatch(
+        agent_name=agent_name,
+        goal="Say hello and tell me what you remember from prior calls.",
+    )
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

agentmint_hermes_runner-0.4.0/examples/tempo_wallet.py

@@ -0,0 +1,38 @@
+"""Dispatch a generic 'hello' goal via Tempo (per-call USDC.e on eip155:4217).
+
+Prerequisites:
+    1. tempo wallet login (one-time, browser-based)
+    2. Funded USDC.e on Tempo mainnet (eip155:4217)
+    3. tempo-request@0.5.2 — newer versions break with "Invalid base64 JSON
+       header". Downgrade with: `tempo cli 0.0.0 downgrade tempo request cli to 0.5.2`
+    4. Pre-mint a subagent once:
+       tempo request -X POST --json \\
+         '{"jsonrpc":"2.0","id":1,"method":"agent.create","params":{"name":"hello-bot"}}' \\
+         https://api.agentmint.store/a2a
+    5. export AGENT_NAME=hello-bot
+    6. (optional) export TEMPO_ACCOUNT=<account-name>
+
+Run:
+    python examples/tempo_wallet.py
+"""
+import os
+
+from agentmint_hermes_runner import AgentMintDispatcher, TempoAuth
+
+
+def main() -> None:
+    dispatcher = AgentMintDispatcher(
+        endpoint=os.environ.get("AGENTMINT_ENDPOINT", "https://api.agentmint.store/a2a"),
+        auth=TempoAuth(account=os.environ.get("TEMPO_ACCOUNT")),
+    )
+
+    agent_name = os.environ["AGENT_NAME"]
+    result = dispatcher.dispatch(
+        agent_name=agent_name,
+        goal="Say hello and tell me what you remember from prior calls.",
+    )
+    print(result)
+
+
+if __name__ == "__main__":
+    main()