@ostraagent/mcp 0.1.11 → 0.1.12

package/README.md

@@ -47,16 +47,16 @@ Keep the file and the passphrase off the machine. On a new machine, run `npx -y
 - **Selling services:** `accept_payments`, `seller_balance`, `seller_withdraw`
 - **Recovery:** `recovery_status`, `set_guardian`, `set_recovery_policy`, `cancel_recovery`, `support_recovery`, `request_recovery`
 - **Withdrawal lock:** `vault_lock` (status; set a withdrawal address on another device, a delay of 36 hours to 14 days and a daily limit: anything else the vault sends counts against the limit, and every loosening waits the delay; off; cancel what waits), `vault_link` (the linked vault a Borro loan is paid to), `vault_approve_hash` (EIP-1271 approvals; under the lock they wait the delay), `guard_vault` (as a guardian of another locked vault: cancel its waiting changes, revoke an approval, sweep it to its withdrawal address, bring its Borro shares or collateral back)
-- **Strategies:** `strategy_plan` (a conservative plan, USDG into a cash vault that passes every check, and, when the agent holds SPY, QQQ or NVDA, a balanced one: the stock as collateral on Borro, USDG borrowed into the cash vault; each with its steps, gas, 30-day earnings net of gas, risks and when it stops; every step earns over 3x its gas in 30 days or is left out), `strategy_apply` (runs a plan step by step, each checked and sized again right before it is signed), `strategy_check` (each run's check of the cash vaults and the carries; urgent exits and repayments run at once), `strategy_report` (what the strategies earn). Only for an agent registered in ERC-8004 (`register_agent`); `strategy_check` and its exits run for every vault
+- **Strategies:** `strategy_plan` (a conservative plan, USDG into a cash vault that passes every check, and, when the agent holds SPY, QQQ or NVDA, a balanced one: the stock as collateral on Borro, USDG borrowed into the cash vault; each with its steps, gas, 30-day earnings net of gas, risks and when it stops; every step earns over 3x its gas in 30 days or is left out), `strategy_apply` (runs a plan step by step, each checked and sized again right before it is signed), `strategy_check` (each run's check of the cash vaults and the carries; urgent exits and repayments run at once), `strategy_report` (what the strategies earn). Only for an agent registered in ERC-8004 (`publish_profile`); `strategy_check` and its exits run for every vault
 - **Trading capital:** `trading` (USDG set aside for the agent's own trades, with Ostra's limits, which an agent may only tighten: a position at most 25% of the capital and no larger than a buy that moves the price 1%; buys stop for the day after a 5% loss that day and for the week after 10% that week)
 - **OstraBreaker:** `breaker` (status, or arm: OstraBreaker as a guardian of the USDG vault, watching each cash vault; when a limit is crossed on chain, Ostra's breaker keeper sends the trip and the position comes back to the vault). `vault_lock set` arms it first by itself
 - **Raeto:** `raeto` (400+ AI models through one OpenAI-compatible API, paid in credits of the vault's own Raeto account: login with EIP-1271, credits, models, fund in USDG from the vault, fund from what the cash vault earned, completions; images are saved as files)
 - **Borro:** `borro_markets`, `borro_position`, `borro_lend` (USDG, or a stock from the agent's vault of it, into Borro's Morpho vault of it), `borro_withdraw`, `borro_collateral`, `borro_borrow` (USDG against the stock vault's collateral, into the vault; the vault caps a loan at half of what the market's LLTV allows), `borro_repay`
 - **Ostrapad:** `pad_publish` (lists offers in the agent's ERC-8004 registration file, paid into its USDG vault; unpublish, status, a voluntary provider bond), `pad_search` (Ostra's index of listed agents, or one agent's listing read from the chain), `pad_order` (orders an offer: the order pinned to IPFS, the budget sent to the job's escrow box and the job created; cancel; appeal a pool decision), `pad_jobs` (the agent's jobs as client, provider or evaluator, with their order and delivery files; accept; claim), `pad_deliver` (the delivery pinned and submitted), `pad_evaluate` (decide a job the agent judges, vote on an appeal panel, the evaluator pool), `pad_earnings`. A job's budget is paid to the provider less 0.5% once its evaluator's approval stands (a pool decision after its 48-hour appeal window), and refunded to the client when rejected or expired; order, delivery and decision files are public JSON on IPFS, checked against their sha256 on chain
 - **Launchpad (closed):** the launchpad takes no new launches or buys; its exits remain: `sell`, `token_vault`, `transfer_token`, `claim_dividends`, `release_creator_payout`, `airdrop_claim`, `airdrop_close`, `vesting_info`, `vesting_release`, `vesting_claim_dividends`
-- **Ostra Swap:** `ostra_swap_quote`, `ostra_swap` (between the agent's vaults of USDG, WETH, $OSTRA, listed stock tokens and launched tokens, routed through Uniswap v3 and v4; tokens by address or symbol; a swap that moves the price more than `maxImpactBps`, 1% by default, is split into up to 16 parts 60 seconds apart, each its own signed swap quoted again right before it is signed), `ostra_swap_split` (the split swaps: their parts, run the parts due, cancel one)
+- **Ostra Swap:** `ostra_swap_quote`, `ostra_swap` (between the agent's vaults of USDG, WETH, $OSTRA, listed stock tokens and launched tokens, routed through Uniswap v3 and v4; tokens by address or symbol; a swap that moves the price more than `maxImpactBps`, 1% by default, is split into up to 16 parts 60 seconds apart, each its own signed swap quoted again right before it is signed; a swap not done within `OSTRA_SWAP_ANSWER_MS` answers `pending` and goes on), `ostra_swap_split` (the split swaps: their parts, run the parts due, cancel one), `ostra_swap_orders` (swaps still running, orders not finished, and the last finished ones with what they paid)
 - **Privacy:** `private_shield` (from a vault into a private note), `private_balance`, `private_swap`, `private_unshield` (to an address, or with `toPrivateVault` to a new private vault of the agent), `private_withdraw` (from a private vault), `private_recover` (finds the notes and private vaults again from the seed alone), `auto_shield` (everything the creator vault holds beyond what it keeps, into private notes). Notes are spent with a zero-knowledge proof made on the agent's machine by the WebAssembly prover the package carries. A spend does not show which note it spends; the token, the amounts, the times, the vault a shield comes from and an unshield's recipient are public, so a private vault's first balance matches the unshield that paid it
-- **Identity:** `profile`, `upload_image`, `publish_profile`, `set_profile`, `register_agent`, `set_agent_uri` (an Ostrapad listing in the registration file is kept when the profile is published again)
+- **Identity:** `profile`, `publish_profile` (no inputs: registers the agent in ERC-8004 when it is not yet, and publishes the same profile for every Ostra agent, "Ostra Agent #id" with Ostra's agent card as its image; an Ostrapad listing in the registration file is kept), `upload_image` (files of Ostrapad orders and deliveries)
 
 Every spend is simulated before its one-time key signs it. When a tool refuses, the error says whether it refused before anything was signed.
 
@@ -84,6 +84,7 @@ All settings are optional.
 | `OSTRA_ETH_RPC_URL` | `https://ethereum-rpc.publicnode.com` | An Ethereum mainnet RPC, for Chainlink's USDe / USD feed the strategies read before lending to a cash vault that can lend against USDe. `off`: no cash goes into such a vault. Never printed |
 | `OSTRA_RAETO_URL` | `https://api.raeto.cc` | Raeto's API. `off` turns the `raeto` tool off |
 | `OSTRA_PAD_INDEXER_URL` | `https://app.ostraagent.xyz` | Ostra's Ostrapad index, for `pad_search` by words. `off` turns that search off (a listing by agent id is still read from the chain) |
+| `OSTRA_SWAP_ANSWER_MS` | `40000` | How long `ostra_swap` and `trading` buy and sell wait for their swap before answering `pending` while it goes on (milliseconds, 1 to 600000), within the 60 s many MCP clients wait for a call |
 | `OSTRA_IPFS_GATEWAYS` | The Ostra uploader (`https://relayer.ostraagent.xyz/v1/ipfs/`), then Pinata's gateway, then ipfs.io | The IPFS gateways profiles and Ostrapad's files are read through, comma-separated, in the order they are tried (each URL ending in `/`). A raw CID is checked against the bytes, whichever gateway answers |
 | `OSTRA_DEPLOYMENT` | Ostra on Robinhood Chain mainnet | Path of another deployment record (JSON). With it, the four services default to off |
 

package/dist/ostra-mcp.js

@@ -18,7 +18,7 @@ var __export = (target, all) => {
 var define_OSTRA_PACKAGED_default;
 var init_define_OSTRA_PACKAGED = __esm({
   "<define:OSTRA_PACKAGED>"() {
-    define_OSTRA_PACKAGED_default = { version: "0.1.11", deployment: { version: 1, chainId: 4663, fromBlock: "91991509", token: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", batchSettlement: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003", vaultImplementation: "0xec0ca4A1393D91c42cA809F7F9dd82Bd597E8E58", vaultBeacon: "0xE9F525B9EaeE48d13AEd28fE146F48f2832a18a0", vaultFactory: "0x043a15c514CFE2c797d33520bFF91a5DCdbf2979", poolImplementation: "0xC04d4a222dC1C966640B977608bE29949b0648ec", poolBeacon: "0x30669Ca534921038a531BBE27116d85bB7406fFF", pool: "0x6ea80F2462e5Fd783B0Ec3B2c7BaC96795980CD6", splitFactory: "0xAAf54A483B2c7c2c5ecFc1eDED5ed1619C1bA882", beaconOwner: "0x55533a51d9bd9b06F2D179d919BB31995EF96E5e", registry: "0xcE6Cc1f93744f4090DA1444Bb8590d9206157506", vaultModule: "0x55A89fF907f5F5756470e2ec5Dc5E4E1C54Da770", launchpad: { hook: "0x63A784afb8905452aDceC471a45E555F5caE68cC", fees: "0x8e79671DC9729476614C78aFcf2345D4c1963801", launchpad: "0xfC57162C0e3f9773F97fEa8d276e957d7c43A6C5", creatorSplit: "0x987994dE6A1d5303B9e3F50977cB0321BA4D033B", dispatcher: "0x44Bb65164b2855f8E80B142d5Fb9bDb72E869986", locker: "0xb593812363bAd70Ee381c7B54c4FC82b0BA3A4A7", devBuy: "0x0e1Fd799E136dcfEcad5695B07Ac5DAc5B2fF4bc", vesting: "0xadD9C1995910457312c156E7D8120D1b447E179a", airdrop: "0xBC798D956aF4c2B104FFC6106d5322294Bc103bb", owner: "0x6569E27A95a6A3E92A311B4Cc6600fed56aA50A2" }, breaker: "0x2E33244dE6A64007204f763e9ef81FC33F1a8e01" }, swapDeployment: { chainId: 4663, fromBlock: "94940585", router: "0x5b9686f384A5Fb768B2360cF0B893F0d1E960B01", stake: "0xaDA4FaB9c8aB9165bf4d6cD9d4Da6d6b32Bb4BC6", buyback: "0xd86083031b7Af66ecD5C9c5e90D4C6d8E661F3f5", spendVerifier: "0x0a0E28a81DE6289e5044950163FfE95b37180e3B", privatePool: "0xe4250895Da2499602Cee4e178Fb46A0cF39F5b76" }, prover: { wasm: "0xd5f3069334ab49a2f955e4b4be9493b80c3f7b2a85f4ff2073a327ef5fbc2747", glue: "0x4bc8bef7c755c83daaf833623f85473a20a7c40b390d8d639d9e4353618a0537" }, relayerUrl: "https://relayer.ostraagent.xyz", keeperUrl: "https://keeper.ostraagent.xyz", aggregatorUrl: "https://aggregator.ostraagent.xyz", aiUrl: "https://ai.ostraagent.xyz" };
+    define_OSTRA_PACKAGED_default = { version: "0.1.12", deployment: { version: 1, chainId: 4663, fromBlock: "91991509", token: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", batchSettlement: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003", vaultImplementation: "0xec0ca4A1393D91c42cA809F7F9dd82Bd597E8E58", vaultBeacon: "0xE9F525B9EaeE48d13AEd28fE146F48f2832a18a0", vaultFactory: "0x043a15c514CFE2c797d33520bFF91a5DCdbf2979", poolImplementation: "0xC04d4a222dC1C966640B977608bE29949b0648ec", poolBeacon: "0x30669Ca534921038a531BBE27116d85bB7406fFF", pool: "0x6ea80F2462e5Fd783B0Ec3B2c7BaC96795980CD6", splitFactory: "0xAAf54A483B2c7c2c5ecFc1eDED5ed1619C1bA882", beaconOwner: "0x55533a51d9bd9b06F2D179d919BB31995EF96E5e", registry: "0xcE6Cc1f93744f4090DA1444Bb8590d9206157506", vaultModule: "0x55A89fF907f5F5756470e2ec5Dc5E4E1C54Da770", launchpad: { hook: "0x63A784afb8905452aDceC471a45E555F5caE68cC", fees: "0x8e79671DC9729476614C78aFcf2345D4c1963801", launchpad: "0xfC57162C0e3f9773F97fEa8d276e957d7c43A6C5", creatorSplit: "0x987994dE6A1d5303B9e3F50977cB0321BA4D033B", dispatcher: "0x44Bb65164b2855f8E80B142d5Fb9bDb72E869986", locker: "0xb593812363bAd70Ee381c7B54c4FC82b0BA3A4A7", devBuy: "0x0e1Fd799E136dcfEcad5695B07Ac5DAc5B2fF4bc", vesting: "0xadD9C1995910457312c156E7D8120D1b447E179a", airdrop: "0xBC798D956aF4c2B104FFC6106d5322294Bc103bb", owner: "0x6569E27A95a6A3E92A311B4Cc6600fed56aA50A2" }, breaker: "0x2E33244dE6A64007204f763e9ef81FC33F1a8e01" }, swapDeployment: { chainId: 4663, fromBlock: "94940585", router: "0x5b9686f384A5Fb768B2360cF0B893F0d1E960B01", stake: "0xaDA4FaB9c8aB9165bf4d6cD9d4Da6d6b32Bb4BC6", buyback: "0xd86083031b7Af66ecD5C9c5e90D4C6d8E661F3f5", spendVerifier: "0x0a0E28a81DE6289e5044950163FfE95b37180e3B", privatePool: "0xe4250895Da2499602Cee4e178Fb46A0cF39F5b76" }, prover: { wasm: "0xd5f3069334ab49a2f955e4b4be9493b80c3f7b2a85f4ff2073a327ef5fbc2747", glue: "0x4bc8bef7c755c83daaf833623f85473a20a7c40b390d8d639d9e4353618a0537" }, relayerUrl: "https://relayer.ostraagent.xyz", keeperUrl: "https://keeper.ostraagent.xyz", aggregatorUrl: "https://aggregator.ostraagent.xyz", aiUrl: "https://ai.ostraagent.xyz" };
   }
 });
 
@@ -13581,6 +13581,14 @@ var init_abi = __esm({
   }
 });
 
+// ../sdk/src/agent-card.ts
+var init_agent_card = __esm({
+  "../sdk/src/agent-card.ts"() {
+    "use strict";
+    init_define_OSTRA_PACKAGED();
+  }
+});
+
 // ../sdk/src/hash.ts
 import { keccak_256 } from "@noble/hashes/sha3.js";
 import { sha256 as sha256Hash } from "@noble/hashes/sha2.js";
@@ -15652,21 +15660,54 @@ var init_breaker = __esm({
 
 // ../sdk/src/chain.ts
 import { BaseError as BaseError2, createPublicClient, defineChain, http } from "viem";
-function invalidParams(e) {
-  const code = (x) => x.code === -32602;
-  return e instanceof BaseError2 ? e.walk(code) !== null : code(e);
+function laggingRead(e) {
+  const lag = (x) => {
+    const o = x;
+    if (o.code === -32602) return true;
+    return o.code === -32e3 && /unsupported block number/i.test(`${String(o.details ?? "")} ${String(o.message ?? "")}`);
+  };
+  return e instanceof BaseError2 ? e.walk(lag) !== null : lag(e);
+}
+function transient(e) {
+  const o = e;
+  if (o === null || typeof o !== "object") return true;
+  if (o.name === "AbortError") return false;
+  if (typeof o.code === "number") return [-1, -32005, -32603, 429, -32007].includes(o.code);
+  if (typeof o.status === "number" && o.status !== 0) return [403, 408, 413, 429, 500, 502, 503, 504].includes(o.status);
+  return true;
 }
-function retryingHttp(url) {
-  const base = http(url, { retryCount: 8, retryDelay: 1e3, timeout: 3e4 });
+function failureText(e, url) {
+  const o = e;
+  const parts = [o?.shortMessage ?? o?.name ?? String(e)];
+  if (typeof o?.code === "number") parts.push(`code ${o.code}`);
+  if (typeof o?.status === "number" && o.status !== 0) parts.push(`HTTP ${o.status}`);
+  if (typeof o?.details === "string" && o.details !== "" && o.details !== parts[0]) parts.push(o.details);
+  return redact(parts.join("; "), url).slice(0, 300);
+}
+function retryingHttp(url, o) {
+  const own = o !== void 0;
+  const base = own ? http(url, { retryCount: 0, timeout: o.timeoutMs ?? RPC_TIMEOUT_MS }) : http(url, { retryCount: RPC_RETRIES, retryDelay: RPC_RETRY_WAIT_MS, timeout: RPC_TIMEOUT_MS });
+  const retries = o?.retryCount ?? RPC_RETRIES;
   return ((params) => {
     const t = base(params);
     const request = (async (args, options) => {
-      for (let attempt = 0; ; attempt++) {
+      let lagging = 0;
+      let failed = 0;
+      for (; ; ) {
         try {
           return await t.request(args, options);
         } catch (e) {
-          if (attempt >= INVALID_PARAMS_RETRIES || !IDEMPOTENT_READS.has(args.method) || !invalidParams(e)) throw e;
-          await new Promise((r) => setTimeout(r, INVALID_PARAMS_WAIT_MS * 2 ** attempt));
+          let wait;
+          if (lagging < INVALID_PARAMS_RETRIES && IDEMPOTENT_READS.has(args.method) && laggingRead(e)) {
+            wait = INVALID_PARAMS_WAIT_MS * 2 ** lagging;
+            lagging++;
+          } else if (own && failed < retries && transient(e)) {
+            const after = e.headers?.get?.("Retry-After");
+            wait = after !== null && after !== void 0 && /^[0-9]+$/.test(after) ? Math.min(Number(after) * 1e3, RETRY_AFTER_MAX_MS) : RPC_RETRY_WAIT_MS * 2 ** failed;
+            failed++;
+          } else throw e;
+          o?.onRetry?.({ method: args.method, retry: lagging + failed, waitMs: wait, error: failureText(e, url) });
+          await new Promise((r) => setTimeout(r, wait));
         }
       }
     });
@@ -15683,7 +15724,7 @@ async function assertRobinhoodChain(client) {
 function redact(text3, secret2) {
   return secret2 === "" ? text3 : text3.split(secret2).join("<rpc>");
 }
-var robinhoodChain, IDEMPOTENT_READS, INVALID_PARAMS_RETRIES, INVALID_PARAMS_WAIT_MS;
+var robinhoodChain, IDEMPOTENT_READS, INVALID_PARAMS_RETRIES, INVALID_PARAMS_WAIT_MS, RPC_RETRIES, RPC_RETRY_WAIT_MS, RPC_TIMEOUT_MS, RETRY_AFTER_MAX_MS;
 var init_chain = __esm({
   "../sdk/src/chain.ts"() {
     "use strict";
@@ -15700,6 +15741,10 @@ var init_chain = __esm({
     IDEMPOTENT_READS = /* @__PURE__ */ new Set(["eth_call", "eth_getCode", "eth_getStorageAt", "eth_getBalance", "eth_getBlockByNumber", "eth_getBlockByHash", "eth_blockNumber", "eth_chainId", "eth_getTransactionReceipt", "eth_getTransactionByHash", "eth_getTransactionCount", "eth_gasPrice"]);
     INVALID_PARAMS_RETRIES = 4;
     INVALID_PARAMS_WAIT_MS = 1e3;
+    RPC_RETRIES = 8;
+    RPC_RETRY_WAIT_MS = 1e3;
+    RPC_TIMEOUT_MS = 3e4;
+    RETRY_AFTER_MAX_MS = 1e4;
   }
 });
 
@@ -19873,6 +19918,7 @@ var init_browser = __esm({
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi();
+    init_agent_card();
     init_aggregator();
     init_airdrop();
     init_backup();
@@ -20406,9 +20452,11 @@ var init_relay = __esm({
       }
     };
     PendingSpendUnpaidError = class extends Error {
-      constructor(message) {
+      onCredit;
+      constructor(message, onCredit) {
         super(message);
         this.name = "PendingSpendUnpaidError";
+        this.onCredit = onCredit;
       }
     };
     RelayerError = class extends Error {
@@ -20705,6 +20753,7 @@ var init_relay = __esm({
       async #post(calls, extra, headers = {}) {
         const body2 = { calls: calls.map((c) => ({ to: getAddress17(c.to), data: c.data })) };
         if (extra.prepay === true) body2.prepay = true;
+        if (extra.onCredit === true) body2.onCredit = true;
         if (extra.payer !== null) body2.payer = extra.payer;
         if (extra.allowFailedSwaps === true) body2.allowFailedSwaps = true;
         return this.#http("POST", "/v1/relay", JSON.stringify(body2), headers);
@@ -20899,9 +20948,11 @@ var init_relay = __esm({
       }
       async send(calls, options = {}) {
         await this.facts();
+        const credit = options.onCredit === true;
+        const post2 = async () => this.#post(calls, { prepay: options.prepay === true, payer: credit ? null : await this.#payer(), allowFailedSwaps: options.allowFailedSwaps === true, onCredit: credit });
         let notSent = "";
         for (let resend = 0; resend < MAX_RESENDS; resend++) {
-          let answer = await this.#post(calls, { prepay: options.prepay === true, payer: await this.#payer(), allowFailedSwaps: options.allowFailedSwaps === true });
+          let answer = await post2();
           let again = false;
           for (let step2 = 0; step2 < MAX_STEPS && !again; step2++) {
             const b = answer.body;
@@ -20911,14 +20962,15 @@ var init_relay = __esm({
               await this.#landed(hash);
               return hash;
             }
+            if (answer.status === 402 && credit) throw new RelayerError(402, "no_credit", "the relayer does not send this spend on credit (it asks for payment); nothing was sent");
             if (answer.status === 402) {
               answer = await this.#pay(calls, answer, options);
               continue;
             }
             if (answer.status === 403 && (error === "vault_in_debt" || error === "open_unpaid")) {
-              if (options.reservation !== void 0 && options.reservation !== null) throw new RelayerError(403, error, String(b?.message ?? error));
+              if (credit || options.reservation !== void 0 && options.reservation !== null) throw new RelayerError(403, error, String(b?.message ?? error));
               await this.#ensureChannel(1n, options.openChannel, null);
-              answer = await this.#post(calls, { prepay: options.prepay === true, payer: await this.#payer(), allowFailedSwaps: options.allowFailedSwaps === true });
+              answer = await post2();
               continue;
             }
             if (answer.status === 409 && error === "not_sent") {
@@ -21463,10 +21515,14 @@ var init_vault = __esm({
        * Runs `fn` with what a vault spend needs to be paid. With the relayer: a
        * reservation of unused relayer channel deposit for its price (a channel is
        * opened first if none has room), released once `fn` is done. When a spend
-       * signed earlier waits and no relayer channel can pay for it, the local fee
-       * payer sends it if it holds the ETH. `moves` is what the spend takes out
-       * of this vault: a relayer channel opened from the buyer vault for it
-       * leaves that much in the buyer vault.
+       * signed earlier waits and no relayer channel can pay for it (its key is
+       * the one a new channel's open needs), the relayer is asked to send it on
+       * credit, as the vault's debt, and the channel opened next pays that debt
+       * with its first voucher; `fn` then runs as usual and its result names what
+       * was sent first (`sentFirst`). Only when the relayer does not send it so,
+       * the local fee payer sends it if it holds the ETH. `moves` is what the
+       * spend takes out of this vault: a relayer channel opened from the buyer
+       * vault for it leaves that much in the buyer vault.
        */
       async #paidSpend(sender, fn, moves = 0n, gas = VAULT_SPEND_GAS, extraWei = 0n) {
         await this.#finishRecoveryFirst(sender);
@@ -21478,10 +21534,30 @@ var init_vault = __esm({
           reservation = await sender.reserve(gas, sender === this.#sender ? this.#opener() : void 0, this.#paysRelayer() ? moves : 0n, extraWei);
         } catch (err) {
           if (!(err instanceof PendingSpendUnpaidError)) throw err;
+          let refused = "";
+          const credit = err.onCredit;
+          if (sender.relayed && credit !== void 0) {
+            let sentFirst = null;
+            try {
+              sentFirst = await (credit.owner === this ? credit.unqueued() : credit.queued());
+            } catch (e) {
+              if (!(e instanceof RelayerError)) throw e;
+              refused = `; the relayer did not send it on credit (${e.message})`;
+            }
+            if (refused === "") {
+              const again = await sender.reserve(gas, sender === this.#sender ? this.#opener() : void 0, this.#paysRelayer() ? moves : 0n, extraWei);
+              try {
+                const r = await fn(sender, again);
+                return sentFirst !== null && r !== null && typeof r === "object" ? { ...r, sentFirst } : r;
+              } finally {
+                sender.release(again);
+              }
+            }
+          }
           const local = new LocalSender(this.#client, this.#transport, this.#keys.feePayer, this.#keys.escrow);
           const need = gas * await this.#client.getGasPrice() * ETH_HEADROOM + extraWei;
           if (await ethBalance(this.#client, this.#keys.feePayer.address) < need) {
-            throw new Error(`${err.message}; send at least ${formatEth(need)} ETH to the fee payer ${this.#keys.feePayer.address} and call again: it sends that operation itself`);
+            throw new Error(`${err.message}${refused}; send at least ${formatEth(need)} ETH to the fee payer ${this.#keys.feePayer.address} and call again: it sends that operation itself`);
           }
           return fn(local, null);
         }
@@ -21491,6 +21567,25 @@ var init_vault = __esm({
           sender.release(reservation);
         }
       }
+      /**
+       * Sends the spend signed earlier through the relayer on credit (SendOptions.onCredit): the vault owes its price, which
+       * the first voucher of the channel opened next pays. Returns what was sent, or null when nothing waits any more.
+       */
+      async #sendPendingOnCredit() {
+        const sender = this.#sender;
+        if (!sender.relayed) return null;
+        const vault = await this.vaultAddress();
+        const v = await this.#read(vault);
+        if (v === null) return null;
+        const credit = {
+          relayed: true,
+          payer: () => sender.payer(),
+          send: (calls, o = {}) => sender.send(calls, { ...o, reservation: null, onCredit: true }),
+          reserve: async () => null,
+          release: () => void 0
+        };
+        return this.#sendPending(vault, v, credit, null);
+      }
       /**
        * Version 3 vaults: the spend is run first with a throwaway key (sdk simulateVaultSpend) and refused before it is
        * signed when it would revert, or land as a failure (a SupportRecovery the other vault refuses). A signed spend that
@@ -21720,7 +21815,11 @@ the signed channel open is kept; the next open_channel or withdraw call sends it
         const v = await this.#read(vault);
         if (v === null) throw new Error(this.#missing());
         if (await this.#pending(v) !== null) {
-          throw new PendingSpendUnpaidError("a vault operation signed earlier waits to be sent and no channel to the relayer has deposit left to pay for it");
+          throw new PendingSpendUnpaidError("a vault operation signed earlier waits to be sent and no channel to the relayer has deposit left to pay for it", {
+            owner: this,
+            queued: () => this.#serial(() => this.#sendPendingOnCredit()),
+            unqueued: () => this.#sendPendingOnCredit()
+          });
         }
         await this.#notFrozen(vault, "the vault");
         const balance = await this.#balance(vault);
@@ -23548,24 +23647,17 @@ function imageUri(value) {
   return value;
 }
 function profileFile(p) {
-  const services = [];
-  const website = link2(p.website, "website");
-  const x = link2(p.x, "x");
-  const telegram = link2(p.telegram, "telegram");
-  if (website !== void 0) services.push({ name: "web", endpoint: website });
-  if (x !== void 0) services.push({ name: "X", endpoint: x });
-  if (telegram !== void 0) services.push({ name: "Telegram", endpoint: telegram });
-  services.push({ name: "agentWallet", endpoint: `eip155:${ROBINHOOD_CHAIN_ID}:${p.vault}` });
+  const id = p.agentId === void 0 || p.agentId === null ? null : p.agentId;
+  if (id !== null && !/^(0|[1-9][0-9]{0,29})$/.test(id)) throw new RangeError("an agent id is a decimal number");
   const image = imageUri(p.image);
-  const description = text2(p.description, "description", 1e3);
   return {
     type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
-    name: text2(p.name, "name", 64),
-    ...description === void 0 ? {} : { description },
+    name: id === null ? AGENT_NAME : `${AGENT_NAME} #${id}`,
+    description: AGENT_DESCRIPTION,
     ...image === void 0 ? {} : { image },
-    services,
+    services: [{ name: "agentWallet", endpoint: `eip155:${ROBINHOOD_CHAIN_ID}:${p.vault}` }],
     active: true,
-    registrations: p.agentId === void 0 || p.agentId === null ? [] : [{ agentId: Number(p.agentId), agentRegistry: `eip155:${ROBINHOOD_CHAIN_ID}:${ERC8004_IDENTITY_REGISTRY}` }]
+    registrations: id === null ? [] : [{ agentId: Number(id), agentRegistry: `eip155:${ROBINHOOD_CHAIN_ID}:${ERC8004_IDENTITY_REGISTRY}` }]
   };
 }
 function tokenMetadataFile(m) {
@@ -23604,6 +23696,9 @@ function uploaderUrl(relayerUrl) {
 function uploadJson(relayerUrl, value) {
   return post(`${uploaderUrl(relayerUrl)}/json`, JSON.stringify(value), "application/json");
 }
+function agentCardUri(relayerUrl, agentId) {
+  return post(`${uploaderUrl(relayerUrl)}/agent-card`, JSON.stringify({ agentId }), "application/json");
+}
 function uploadImage(relayerUrl, bytes) {
   const base = uploaderUrl(relayerUrl);
   if (bytes.length === 0 || bytes.length > MAX_UPLOAD_IMAGE_BYTES) throw new RangeError(`the image must be 1 to ${MAX_UPLOAD_IMAGE_BYTES} bytes (it is ${bytes.length})`);
@@ -23611,13 +23706,15 @@ function uploadImage(relayerUrl, bytes) {
   if (type === null) throw new RangeError("the image is not a PNG, JPEG, WebP or GIF");
   return post(`${base}/image`, new Blob([new Uint8Array(bytes)], { type }), type);
 }
-var MAX_UPLOAD_IMAGE_BYTES;
+var MAX_UPLOAD_IMAGE_BYTES, AGENT_NAME, AGENT_DESCRIPTION;
 var init_publish = __esm({
   "../core/src/publish.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_src();
     MAX_UPLOAD_IMAGE_BYTES = 1048576;
+    AGENT_NAME = "Ostra Agent";
+    AGENT_DESCRIPTION = "An AI agent with an Ostra post-quantum privacy vault on Robinhood Chain. Its earnings and payments stay in its own vault, signed with one-time keys.";
   }
 });
 
@@ -23692,6 +23789,7 @@ var init_launchpad = __esm({
     STAND_IN_URI = `ipfs://bafkrei${"a".repeat(52)}`;
     LaunchpadService = class {
       #client;
+      #logsClient;
       #transport;
       #config;
       #keys;
@@ -23706,6 +23804,7 @@ var init_launchpad = __esm({
       constructor(p) {
         if (p.creator.kind !== "creator" || p.buyer.kind !== "buyer") throw new Error("the launchpad takes the agent's buyer and creator vaults");
         this.#client = p.client;
+        this.#logsClient = p.logsClient ?? p.client;
         this.#transport = p.transport;
         this.#config = p.config;
         this.#keys = p.keys;
@@ -24494,6 +24593,52 @@ var init_launchpad = __esm({
         const text3 = await this.#folder.read("agent.json");
         return text3 === void 0 ? null : JSON.parse(text3);
       }
+      /**
+       * The agent's registration read from the chain when agent.json does not hold it: an identity its creator vault
+       * registered (the Identity Registry's Registered events from the deployment's first block) and still owns. A
+       * registration that landed after its call stopped (the relayer refused the send and a later operation sent the kept
+       * spend, or the process stopped before agent.json was written) is found here and written to agent.json, so the agent
+       * is never registered twice. An identity someone else registered and sent to the creator vault (an ERC-721 transfer
+       * the vault accepts) is no registration of this agent: with no Registered event of the vault, this is null. A
+       * registration sent again just now is read from its receipt instead (#recordFromReceipt), not from logs that may lag.
+       */
+      async #recoverAgentRecord() {
+        const vault = getAddress24(await this.#creator.vaultAddress());
+        const owned = await this.#client.readContract({ address: ERC8004_IDENTITY_REGISTRY, abi: identityRegistryAbi, functionName: "balanceOf", args: [vault] });
+        if (owned === 0n) return null;
+        const to = await this.#logsClient.getBlockNumber({ cacheTime: 0 });
+        const logs = await getLogsChunked(this.#logsClient, { address: ERC8004_IDENTITY_REGISTRY, event: agentRegisteredEvent, args: { owner: vault }, fromBlock: BigInt(this.#config.deployment.fromBlock), toBlock: to });
+        for (const log2 of logs) {
+          const { agentId, agentURI } = log2.args;
+          const who = await readAgentIdentity(this.#client, agentId);
+          if (who === null || getAddress24(who.owner) !== vault) continue;
+          const record = { agentId: agentId.toString(), uri: agentURI, txHash: log2.transactionHash, at: Math.floor(Date.now() / 1e3) };
+          await this.#folder.write("agent.json", JSON.stringify(record, null, 2));
+          return record;
+        }
+        return null;
+      }
+      /**
+       * The registration transaction `txHash` of the creator vault, read from its receipt (the vault's AgentRegistered
+       * event) and written to agent.json; null when it registered nothing. `uri` is the file it registered with.
+       */
+      async #recordFromReceipt(txHash, uri2) {
+        const vault = getAddress24(await this.#creator.vaultAddress());
+        const receipt = await this.#client.getTransactionReceipt({ hash: txHash });
+        let agentId;
+        for (const log2 of receipt.logs) {
+          if (getAddress24(log2.address) !== vault) continue;
+          try {
+            const e = decodeEventLog3({ abi: ostraVaultAbi, data: log2.data, topics: log2.topics });
+            if (e.eventName === "AgentRegistered") agentId = e.args.agentId.toString();
+          } catch {
+          }
+        }
+        if (agentId === void 0) return null;
+        const record = { agentId, uri: uri2, txHash, at: Math.floor(Date.now() / 1e3) };
+        await this.#folder.write("agent.json", JSON.stringify(record, null, 2));
+        return record;
+      }
       /** The agent's identity: its creator vault, the profile URI it set and its ERC-8004 agent id; or, given `account`, that account's profile URI. */
       async profile(accountText) {
         const account = accountText === void 0 ? await this.#creator.vaultAddress() : address2(accountText, "account");
@@ -24510,32 +24655,21 @@ var init_launchpad = __esm({
       /** Registers the creator vault as an agent in the ERC-8004 Identity Registry, its registration file at `uri`; the vault owns the identity and is its agentWallet. */
       async registerAgent(uri2) {
         checkUri(uri2);
-        const vault = await this.#identityVault();
-        const existing = await this.#agentRecord();
-        if (existing !== null) throw new Error(`this agent is registered already as agent ${existing.agentId}: update it with set_agent_uri; nothing was signed`);
+        await this.#identityVault();
+        const existing = await this.#agentRecord() ?? await this.#recoverAgentRecord();
+        if (existing !== null) throw new Error(`this agent is registered already as agent ${existing.agentId}: publish_profile publishes its profile again; nothing was signed`);
         const r = await this.#simulatedSpend(this.#creator, this.#creatorSender, VAULT_ACTION.REGISTER_AGENT, registerAgentParams(uri2), "agent registration");
         if (r.status !== "sent") return r;
-        const receipt = await this.#client.getTransactionReceipt({ hash: r.txHash });
-        let agentId;
-        for (const log2 of receipt.logs) {
-          if (getAddress24(log2.address) !== vault) continue;
-          try {
-            const e = decodeEventLog3({ abi: ostraVaultAbi, data: log2.data, topics: log2.topics });
-            if (e.eventName === "AgentRegistered") agentId = e.args.agentId.toString();
-          } catch {
-          }
-        }
-        if (agentId === void 0) throw new Error(`the registration ${r.txHash} landed without an AgentRegistered event`);
-        const record = { agentId, uri: uri2, txHash: r.txHash, at: Math.floor(Date.now() / 1e3) };
-        await this.#folder.write("agent.json", JSON.stringify(record, null, 2));
-        return { ...r, agentId };
+        const record = await this.#recordFromReceipt(r.txHash, uri2);
+        if (record === null) throw new Error(`the registration ${r.txHash} landed without an AgentRegistered event`);
+        return { ...r, agentId: record.agentId };
       }
       /** Points the agent's ERC-8004 identity at a new registration file. */
       async setAgentUri(uri2) {
         checkUri(uri2);
         await this.#identityVault();
         const record = await this.#agentRecord();
-        if (record === null) throw new Error("this agent has no ERC-8004 identity yet: register_agent first; nothing was signed");
+        if (record === null) throw new Error("this agent has no ERC-8004 identity yet: publish_profile registers it; nothing was signed");
         const r = await this.#simulatedSpend(this.#creator, this.#creatorSender, VAULT_ACTION.SET_AGENT_URI, setAgentUriParams({ agentId: BigInt(record.agentId), uri: uri2 }), "agent registration file");
         if (r.status === "sent") await this.#folder.write("agent.json", JSON.stringify({ ...record, uri: uri2, at: Math.floor(Date.now() / 1e3) }, null, 2));
         return r;
@@ -24561,15 +24695,38 @@ var init_launchpad = __esm({
         if (version < VAULT_VERSION) throw new Error(`the creator vault ${s.vault} runs version ${version}, not ${VAULT_VERSION}; nothing was signed`);
       }
       /**
-       * Publishes the agent's profile: builds its ERC-8004 registration file (name, description, image, links, the
-       * creator vault as its agentWallet, its registration once it has one), pins it through the uploader, sets it in
-       * OstraRegistry, and points the ERC-8004 identity at it too when the agent is registered.
+       * Publishes the agent's Ostra profile, the same for every Ostra agent (profileFile: its name and number, Ostra's
+       * description, its Ostra card, its creator vault as agentWallet), and registers the agent in ERC-8004 when it is not
+       * registered yet: the profile without a number is published, the creator vault registers the agent with it, and the
+       * profile is published again with the agent's number and card, its ERC-8004 identity pointed at it. Called again, it
+       * carries on from where it stopped (what the chain and agent.json hold decides).
        */
-      async publishProfile(p) {
-        const vault = await this.#identityVault();
+      async publishProfile() {
+        const before = await this.#agentRecord() ?? await this.#recoverAgentRecord();
+        if (before !== null) return { agentId: before.agentId, registration: null, unnumbered: null, ...await this.#publishProfileFile(before) };
+        const first = await this.#publishProfileFile(null);
+        const unnumbered = { uri: first.uri, profile: first.profile };
+        if (first.profile.status !== "sent") {
+          const resent = first.profile.status === "resent_pending" ? first.profile.resent : null;
+          const landed = resent !== null && resent.operation === "vault_spend" && resent.action === VAULT_ACTION.REGISTER_AGENT ? await this.#recordFromReceipt(resent.txHash, first.uri) : null;
+          if (landed === null) return { agentId: null, registration: null, unnumbered, ...first };
+          return { agentId: landed.agentId, registration: null, unnumbered, ...await this.#publishProfileFile(landed) };
+        }
+        const registration = await this.registerAgent(first.uri);
         const record = await this.#agentRecord();
-        const file = profileFile({ ...p, vault, agentId: record?.agentId ?? null });
+        if (registration.status !== "sent" || record === null) return { agentId: null, registration, unnumbered, ...first };
+        return { agentId: record.agentId, registration, unnumbered, ...await this.#publishProfileFile(record) };
+      }
+      /**
+       * Builds the profile of the agent (`record`: its registration, or null before it has one), pins it through the
+       * uploader, sets it in OstraRegistry (for the creator vaults of the other pairs it launched from too), and points the
+       * ERC-8004 identity at it when the agent is registered.
+       */
+      async #publishProfileFile(record) {
+        const vault = await this.#identityVault();
+        const agentId = record?.agentId ?? null;
         uploaderUrl(this.#config.relayerUrl);
+        const file = profileFile({ vault, agentId, image: await agentCardUri(this.#config.relayerUrl, agentId) });
         const beforeUri = await this.#profileUri(vault);
         const before = await readIpfsJson(beforeUri);
         if (beforeUri !== null && beforeUri.startsWith("ipfs://") && before === null) throw new Error(`the profile published before (${beforeUri}) cannot be read now, so its Ostrapad listing could not be kept: try again later; nothing was signed`);
@@ -24927,7 +25084,7 @@ var init_pad2 = __esm({
       publish(offers) {
         return this.#serial(async () => {
           const { agentId, creatorVault } = await this.#p.identity();
-          if (agentId === null) throw new Error("this agent is not registered in ERC-8004 yet: publish_profile, then register_agent; nothing was signed");
+          if (agentId === null) throw new Error("this agent is not registered in ERC-8004 yet: publish_profile registers it; nothing was signed");
           const vault = await this.#vault();
           const current = await this.#p.currentFile();
           if (current === null) throw new Error("this agent has no published profile yet: publish_profile first; nothing was signed");
@@ -26024,10 +26181,10 @@ var init_raeto = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/abi.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/abi.ts
 var ostraRouterAbi, ostraStakeAbi, ostraPrivatePoolAbi, OSTRA_SWAP_ESCROW_CREATION_CODE, OSTRA_SHIELD_ESCROW_CREATION_CODE, ostraQuoteBatchAbi, OSTRA_QUOTE_BATCH_CREATION_CODE;
 var init_abi2 = __esm({
-  "../../ostra-swap/sdk/src/abi.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/abi.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     ostraRouterAbi = [
@@ -28892,10 +29049,10 @@ var init_abi2 = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/constants.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/constants.ts
 var LOG_WINDOW_BLOCKS2, USDG2, WETH2, HUBS, ETH, UNISWAP_V3_FACTORY, UNISWAP_V3_QUOTER_V2, V3_FEE_TIERS, UNISWAP_V4_POOL_MANAGER2, UNISWAP_V4_QUOTER, MULTICALL32, OSTRA_HOOK, PONS_HOOK2, ROUTABLE_HOOKS, FEE_TIERS, COMMAND, V4_ACTION, CONTRACT_BALANCE, MSG_SENDER, ADDRESS_THIS, OPEN_DELTA, QUOTE_GAS_LIMIT, QUOTES_PER_CALL, QUOTE_GAS_LIMIT_RETRY, QUOTES_PER_RETRY_CALL, QUOTE_BATCH_OVERHEAD_GAS, V3_MIN_SQRT_PRICE_LIMIT, V3_MAX_SQRT_PRICE_LIMIT, DEFAULT_SLIPPAGE_BPS, MAX_SLIPPAGE_BPS, DEFAULT_ORDER_TTL_SECONDS;
 var init_constants2 = __esm({
-  "../../ostra-swap/sdk/src/constants.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/constants.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     LOG_WINDOW_BLOCKS2 = 10000000n;
@@ -28937,11 +29094,11 @@ var init_constants2 = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/uniswap.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/uniswap.ts
 import { parseAbi as parseAbi7, parseAbiItem as parseAbiItem6 } from "viem";
 var v3FactoryAbi, v3PoolAbi, quoterV2Abi, poolKeyComponents, v4QuoterAbi, exactInputSingleParam, poolManagerAbi, initializeEvent, erc20Abi, multicall3Abi2;
 var init_uniswap = __esm({
-  "../../ostra-swap/sdk/src/uniswap.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/uniswap.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     v3FactoryAbi = parseAbi7(["function getPool(address tokenA, address tokenB, uint24 fee) view returns (address)"]);
@@ -29033,7 +29190,7 @@ var init_uniswap = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/legs.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/legs.ts
 import { concatHex, encodeAbiParameters as encodeAbiParameters10, encodePacked as encodePacked4, getAddress as getAddress28, toHex as toHex5 } from "viem";
 function legFor(pool, tokenIn, tokenOut, recipient = MSG_SENDER) {
   const inAddr = getAddress28(tokenIn);
@@ -29070,7 +29227,7 @@ function legFor(pool, tokenIn, tokenOut, recipient = MSG_SENDER) {
 }
 var NO_LEG, byte;
 var init_legs = __esm({
-  "../../ostra-swap/sdk/src/legs.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/legs.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_constants2();
@@ -29080,7 +29237,7 @@ var init_legs = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/pools.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/pools.ts
 import { encodeAbiParameters as encodeAbiParameters11, encodeFunctionData as encodeFunctionData12, decodeFunctionResult as decodeFunctionResult3, getAddress as getAddress29, hexToBigInt as hexToBigInt2, keccak256 as keccak25617, toHex as toHex6, zeroAddress as zeroAddress16 } from "viem";
 function stateSlot(id, offset) {
   const base = hexToBigInt2(keccak25617(encodeAbiParameters11([{ type: "bytes32" }, { type: "uint256" }], [id, POOLS_SLOT3])));
@@ -29143,7 +29300,7 @@ async function hubPools(client, logsClient, index, token, hub) {
 }
 var POOLS_SLOT3, LIQUIDITY_OFFSET2, PoolIndex;
 var init_pools2 = __esm({
-  "../../ostra-swap/sdk/src/pools.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/pools.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_constants2();
@@ -29189,7 +29346,7 @@ var init_pools2 = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/route.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/route.ts
 import { decodeAbiParameters as decodeAbiParameters5, decodeFunctionResult as decodeFunctionResult4, encodeDeployData as encodeDeployData2, encodeFunctionData as encodeFunctionData13, getAddress as getAddress30 } from "viem";
 function routedToken(token) {
   const t = getAddress30(token);
@@ -29313,7 +29470,7 @@ function routeLegs(route) {
 }
 var NoRouteError, quoteResults;
 var init_route = __esm({
-  "../../ostra-swap/sdk/src/route.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/route.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
@@ -29339,7 +29496,7 @@ var init_route = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/orders.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/orders.ts
 import { encodeAbiParameters as encodeAbiParameters12, encodeFunctionData as encodeFunctionData14, getAddress as getAddress31, getContractAddress as getContractAddress4, isAddress as isAddress14, keccak256 as keccak25618, toHex as toHex7 } from "viem";
 function parseSwapDeployment(json) {
   const r = json;
@@ -29393,7 +29550,7 @@ function executeEscrowData(order, route) {
 }
 var ZERO, MAX_UINT32, MAX_UINT64, MAX_STANDING_ORDER_SECONDS, legParam, orderParam;
 var init_orders = __esm({
-  "../../ostra-swap/sdk/src/orders.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/orders.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
@@ -29432,7 +29589,7 @@ var init_orders = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/private.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/private.ts
 import { encodeAbiParameters as encodeAbiParameters13, encodeFunctionData as encodeFunctionData15, getAbiItem, getAddress as getAddress32, getContractAddress as getContractAddress5, keccak256 as keccak25619, parseEventLogs, toHex as toHex8 } from "viem";
 function packDigest(elements) {
   if (elements.length !== 8) throw new Error("a digest has 8 field elements");
@@ -29632,7 +29789,7 @@ async function swapOutputNote(prover, sk, outRho, spend, swap, receipt, pool) {
 }
 var FIELD_P, TREE_DEPTH, PRIVATE_SWAP_FEE_BPS, UNSHIELD_DOMAIN, SWAP_DOMAIN, MAX_AMOUNT, MAX_UINT642, ZERO2, noteAddedEvent, PoolTrees;
 var init_private = __esm({
-  "../../ostra-swap/sdk/src/private.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/private.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
@@ -29748,19 +29905,19 @@ var init_private = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/reads.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/reads.ts
 import { getAddress as getAddress33 } from "viem";
 var init_reads2 = __esm({
-  "../../ostra-swap/sdk/src/reads.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/reads.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
   }
 });
 
-// ../../ostra-swap/sdk/src/index.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/index.ts
 var init_src2 = __esm({
-  "../../ostra-swap/sdk/src/index.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/index.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_abi2();
@@ -31437,7 +31594,7 @@ var init_strategy2 = __esm({
           if (who !== null && getAddress37(who.owner) === creatorVault && getAddress37(who.wallet) === creatorVault) return { agentId: id.toString(), creatorVault };
         }
         throw new StrategyGateError(
-          `Ostra's strategies are for agents registered in the ERC-8004 Identity Registry through Ostra: the creator vault ${creatorVault} must own the agent's identity and be its agentWallet${ids.length === 0 ? " (it has none)" : ` (agent ${ids.map(String).join(", ")} is not)`}. Register with register_agent (after publish_profile), then ask again.`
+          `Ostra's strategies are for agents registered in the ERC-8004 Identity Registry through Ostra: the creator vault ${creatorVault} must own the agent's identity and be its agentWallet${ids.length === 0 ? " (it has none)" : ` (agent ${ids.map(String).join(", ")} is not)`}. Register with publish_profile (it registers the agent), then ask again.`
         );
       }
       // -------------------------------------------------------------------------------------------------------------------
@@ -32336,7 +32493,7 @@ function refusalOf(reason, outDecimals) {
     return `revert data ${reason.slice(0, 2 + 8 * 2)}${reason.length > 18 ? "\u2026" : ""} (not one of OstraRouter's errors: from a pool or the Universal Router)`;
   }
 }
-var SWAP_DIR, ESCROW_SWAP_GAS, DEFAULT_SWAP_SLIPPAGE_BPS, MAX_SWAP_SLIPPAGE_BPS, DEFAULT_SWAP_MAX_IMPACT_BPS, MAX_SWAP_MAX_IMPACT_BPS, SPLIT_MAX_PARTS, SPLIT_INTERVAL_SECONDS, SPLIT_SLACK_SECONDS, POOL_INDEX2, ORDER_PREFIX, SPLIT_PREFIX, address4, SwapService;
+var SWAP_DIR, ESCROW_SWAP_GAS, DEFAULT_SWAP_SLIPPAGE_BPS, MAX_SWAP_SLIPPAGE_BPS, DEFAULT_SWAP_MAX_IMPACT_BPS, MAX_SWAP_MAX_IMPACT_BPS, SPLIT_MAX_PARTS, SPLIT_INTERVAL_SECONDS, SPLIT_SLACK_SECONDS, POOL_INDEX2, ORDER_PREFIX, SPLIT_PREFIX, DONE_PREFIX, DONE_ORDERS_KEPT, address4, SwapService;
 var init_swap = __esm({
   "../core/src/swap.ts"() {
     "use strict";
@@ -32360,6 +32517,8 @@ var init_swap = __esm({
     POOL_INDEX2 = "pool-index.json";
     ORDER_PREFIX = "order-";
     SPLIT_PREFIX = "split-";
+    DONE_PREFIX = "done-";
+    DONE_ORDERS_KEPT = 100;
     address4 = (text3, what) => {
       if (!/^0x[0-9a-fA-F]{40}$/.test(text3)) throw new RangeError(`${what} is not an address`);
       return getAddress38(text3);
@@ -32572,7 +32731,23 @@ var init_swap = __esm({
             const escrow = escrowAddress(this.#p.swap.router, order);
             const execute = executeEscrowData(order, p.route);
             await p.from.checkSpend(VAULT_ACTION.TRANSFER, transferParams({ to: escrow, amount: p.amountIn }), "the swap's transfer to its escrow", this.#p.sender);
-            await this.#keep({ version: 1, hash: orderHash(order), escrow, tokenIn: p.tokenIn, amountIn: p.amountIn.toString(), vaultNonce: v.nonce.toString(), deadline: order.deadline.toString(), execute, at: Date.now() });
+            await this.#keep({
+              version: 1,
+              hash: orderHash(order),
+              escrow,
+              tokenIn: p.tokenIn,
+              amountIn: p.amountIn.toString(),
+              vaultNonce: v.nonce.toString(),
+              deadline: order.deadline.toString(),
+              execute,
+              at: Date.now(),
+              fromBlock: fromBlock.toString(),
+              tokenOut: p.tokenOut,
+              from: vault,
+              to: p.to,
+              inDecimals: p.inDecimals,
+              outDecimals: p.outDecimals
+            });
             await o.onOrder?.(orderHash(order), fromBlock, escrow);
             const signed = await signVaultTransfer(keychain, v, { chainId, to: escrow, amount: p.amountIn });
             const calls = [spendCall(vault, signed), { to: this.#p.swap.router, data: execute }];
@@ -32601,6 +32776,21 @@ var init_swap = __esm({
             note: `the swap landed in ${result.txHash}; what it paid could not be read now (${e.message.split("\n")[0]}): do not send it again, its order ${orderHash(placed2)} is read again later`
           };
         }
+        await this.#keepDone({
+          version: 1,
+          order: orderHash(placed2),
+          txHash: result.txHash,
+          swapped: outcome.swapped,
+          tokenIn: p.tokenIn,
+          tokenOut: p.tokenOut,
+          amountIn: formatUnitsAmount(p.amountIn, p.inDecimals),
+          amountOut: formatUnitsAmount(outcome.amountOut, p.outDecimals),
+          minOut: formatUnitsAmount(p.route.minOut, p.outDecimals),
+          from: p.fromVault,
+          to: p.to,
+          ...outcome.swapped ? {} : { refusal: outcome.why ?? "OstraRouter gave no reason" },
+          at: Date.now()
+        });
         await this.#p.folder.remove(`${ORDER_PREFIX}${orderHash(placed2)}.json`);
         return {
           status: "sent",
@@ -32937,6 +33127,92 @@ var init_swap = __esm({
         if (swapped) return { swapped, amountOut };
         return { swapped, amountOut: 0n, ...reason === null ? {} : { why: refusalOf(reason, outDecimals) } };
       }
+      /** Keeps a finished order for ostra_swap_orders, and drops the oldest beyond DONE_ORDERS_KEPT. */
+      async #keepDone(d) {
+        await this.#p.folder.ensure();
+        await this.#p.folder.write(`${DONE_PREFIX}${d.order.toLowerCase()}.json`, `${JSON.stringify(d)}
+`);
+        const names = (await this.#p.folder.list()).filter((n) => n.startsWith(DONE_PREFIX) && n.endsWith(".json"));
+        if (names.length <= DONE_ORDERS_KEPT) return;
+        const dated = [];
+        for (const n of names) {
+          const text3 = await this.#p.folder.read(n);
+          dated.push({ name: n, at: text3 === void 0 ? 0 : Number(JSON.parse(text3).at) });
+        }
+        dated.sort((a, b) => a.at - b.at);
+        for (const x of dated.slice(0, dated.length - DONE_ORDERS_KEPT)) await this.#p.folder.remove(x.name);
+      }
+      /**
+       * Keeps what a kept order did once the sweep finishes it: from the transaction that executed it (`tx`), else from
+       * OstraRouter's events from the record's block. Best effort: an order whose events cannot be read now is not kept
+       * (a record from before 0.1.12 has no block to search from).
+       */
+      async #doneFrom(r, tx) {
+        try {
+          let hash = tx;
+          if (hash === null && r.fromBlock !== void 0) {
+            const toBlock = await this.#p.logsClient.getBlockNumber({ cacheTime: 0 });
+            const logs = await getLogsChunked(this.#p.logsClient, { address: this.#p.swap.router, event: getAbiItem2({ abi: ostraRouterAbi, name: "EscrowExecuted" }), args: { orderHash: r.hash }, fromBlock: BigInt(r.fromBlock), toBlock });
+            const moved = logs.find((l) => l.args.received !== 0n);
+            hash = moved === void 0 ? null : moved.transactionHash;
+          }
+          if (hash === null) return;
+          const inDecimals = r.inDecimals ?? await tokenDecimals(this.#p.client, r.tokenIn);
+          const outDecimals = r.outDecimals ?? (r.tokenOut === void 0 ? 18 : await tokenDecimals(this.#p.client, r.tokenOut));
+          const o = await this.#outcome(hash, r.hash, outDecimals);
+          await this.#keepDone({
+            version: 1,
+            order: r.hash,
+            txHash: hash,
+            swapped: o.swapped,
+            tokenIn: r.tokenIn,
+            tokenOut: r.tokenOut ?? null,
+            amountIn: formatUnitsAmount(BigInt(r.amountIn), inDecimals),
+            amountOut: formatUnitsAmount(o.amountOut, outDecimals),
+            minOut: null,
+            from: r.from ?? null,
+            to: r.to ?? null,
+            ...o.swapped ? {} : { refusal: o.why ?? "OstraRouter gave no reason" },
+            at: Date.now()
+          });
+        } catch {
+        }
+      }
+      /**
+       * The agent's orders kept here: those not finished (signed or about to be, or landed and being finished; oldest
+       * first) and the finished ones (newest first, at most `limit`). With `order`, that order alone in either list.
+       */
+      async orders(o = {}) {
+        const want = o.order?.toLowerCase();
+        const open3 = [];
+        const finished = [];
+        for (const name of await this.#p.folder.list()) {
+          const isOrder = name.startsWith(ORDER_PREFIX);
+          if (!isOrder && !name.startsWith(DONE_PREFIX) || !name.endsWith(".json")) continue;
+          if (want !== void 0 && name.slice((isOrder ? ORDER_PREFIX : DONE_PREFIX).length, -".json".length).toLowerCase() !== want) continue;
+          const text3 = await this.#p.folder.read(name);
+          if (text3 === void 0) continue;
+          if (!isOrder) {
+            finished.push(JSON.parse(text3));
+            continue;
+          }
+          const r = JSON.parse(text3);
+          const inDecimals = r.inDecimals ?? await tokenDecimals(this.#p.client, r.tokenIn);
+          const x = { order: r.hash, tokenIn: r.tokenIn, tokenOut: r.tokenOut ?? null, amountIn: formatUnitsAmount(BigInt(r.amountIn), inDecimals), escrow: r.escrow, state: "open", at: r.at };
+          if (r.fromBlock !== void 0) {
+            const res = await this.orderResult(r.hash, BigInt(r.fromBlock), r.escrow);
+            if (res.spent > 0n || res.received > 0n) {
+              x.state = "landed";
+              x.spent = formatUnitsAmount(res.spent, inDecimals);
+              x.received = formatUnitsAmount(res.received, r.outDecimals ?? 18);
+            }
+          }
+          open3.push(x);
+        }
+        open3.sort((a, b) => a.at - b.at);
+        finished.sort((a, b) => b.at - a.at);
+        return { open: open3, finished: finished.slice(0, o.limit ?? 20) };
+      }
       /**
        * Finishes the orders whose escrow was paid without being executed (a signed spend sent again on its own):
        * executeEscrow sends the input along the order's route, or back to its vault past the deadline. Records of orders
@@ -32953,11 +33229,15 @@ var init_swap = __esm({
             const nonce = (await this.#p.vaultFor(r.tokenIn).state()).nonce;
             const held = await tokenBalance(this.#p.client, r.tokenIn, r.escrow);
             if (held >= BigInt(r.amountIn)) {
-              await this.#p.sender.send([{ to: this.#p.swap.router, data: r.execute }]);
+              const tx = await this.#p.sender.send([{ to: this.#p.swap.router, data: r.execute }]);
+              await this.#doneFrom(r, tx);
               await this.#p.folder.remove(name);
               continue;
             }
-            if (nonce !== null && nonce > BigInt(r.vaultNonce)) await this.#p.folder.remove(name);
+            if (nonce !== null && nonce > BigInt(r.vaultNonce)) {
+              await this.#doneFrom(r, null);
+              await this.#p.folder.remove(name);
+            }
           } catch (err) {
             failures.push({ order: r.hash, error: err instanceof Error ? err.message : String(err) });
           }
@@ -33821,7 +34101,7 @@ var init_backup_cli = __esm({
   }
 });
 
-// ../../ostra-swap/sdk/src/cli-prover.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/cli-prover.ts
 import { spawn } from "node:child_process";
 function cliProver(binary, timeoutMs = PROVER_TIMEOUT_MS) {
   return (command, request) => new Promise((resolve, reject) => {
@@ -33862,14 +34142,14 @@ function cliProver(binary, timeoutMs = PROVER_TIMEOUT_MS) {
 }
 var PROVER_TIMEOUT_MS;
 var init_cli_prover = __esm({
-  "../../ostra-swap/sdk/src/cli-prover.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/cli-prover.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     PROVER_TIMEOUT_MS = 12e4;
   }
 });
 
-// ../../ostra-swap/sdk/src/wasm-prover.ts
+// ../../../../../../srv/apps/ostra-swap/sdk/src/wasm-prover.ts
 import { bytesToHex as bytesToHex17 } from "viem";
 async function sha256Hex(bytes) {
   return bytesToHex17(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)));
@@ -33905,7 +34185,7 @@ async function wasmProver(glue, bytes, sha2564) {
 }
 var WasmProverTrapped, initialized, trapped;
 var init_wasm_prover = __esm({
-  "../../ostra-swap/sdk/src/wasm-prover.ts"() {
+  "../../../../../../srv/apps/ostra-swap/sdk/src/wasm-prover.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     WasmProverTrapped = class extends Error {
@@ -34026,7 +34306,7 @@ var init_agent = __esm({
         this.creator = new VaultService(client, transport, config, p.creatorKeys, creatorSender, "creator");
         this.creatorRelayer?.attachBuyerVault(this.creator);
         this.creatorChannels = new ChannelService(client, config, p.creatorKeys, this.creator, creatorSender);
-        this.launchpad = config.deployment.launchpad === void 0 ? null : new LaunchpadService({ client, transport, config, keys, buyer: this.buyer, buyerSender: this.sender, creator: this.creator, creatorSender });
+        this.launchpad = config.deployment.launchpad === void 0 ? null : new LaunchpadService({ client, transport, config, keys, buyer: this.buyer, buyerSender: this.sender, creator: this.creator, creatorSender, logsClient: createPublicClient2({ chain: robinhoodChain, transport: http2(config.logsRpcUrl, { retryCount: 6, retryDelay: 2e3 }) }) });
         this.shield = new ShieldService(client, config, keys, this.buyer, this.sender);
         this.creatorShield = new ShieldService(client, config, keys, this.creator, creatorSender);
         this.unshield = new UnshieldService(client, config, keys, this.shield, (index) => this.privateVault(index));
@@ -34325,6 +34605,12 @@ async function proverConfig(env) {
   }
   return { kind: "wasm", dir, sha256: sha2564 };
 }
+function swapAnswerMs(env) {
+  const v = env.OSTRA_SWAP_ANSWER_MS;
+  if (v === void 0 || v === "") return DEFAULT_SWAP_ANSWER_MS;
+  if (!/^[1-9][0-9]{0,5}$/.test(v) || Number(v) > 6e5) throw new Error("OSTRA_SWAP_ANSWER_MS is a whole number of milliseconds from 1 to 600000");
+  return Number(v);
+}
 function serviceUrl(env, name, fallback) {
   const value = env[name];
   if (value === void 0 || value === "") return fallback;
@@ -34374,6 +34660,7 @@ async function loadConfig(env = process.env) {
     swap,
     logsRpcUrl,
     privateLocalSpends: env.OSTRA_PRIVATE_LOCAL_SPENDS === "yes",
+    swapAnswerMs: swapAnswerMs(env),
     prover,
     chainId: deployment.chainId,
     rpcUrl: rpcUrl ?? ROBINHOOD_PUBLIC_RPC,
@@ -34385,7 +34672,7 @@ async function loadConfig(env = process.env) {
     aiUrl: serviceUrl(env, "OSTRA_AI_URL", services?.aiUrl ?? null)
   };
 }
-var PROVER_WASM_FILES, PAD_INDEXER_URL, ETHEREUM_PUBLIC_RPC;
+var PROVER_WASM_FILES, PAD_INDEXER_URL, ETHEREUM_PUBLIC_RPC, DEFAULT_SWAP_ANSWER_MS;
 var init_config2 = __esm({
   "src/config.ts"() {
     "use strict";
@@ -34398,10 +34685,12 @@ var init_config2 = __esm({
     PROVER_WASM_FILES = ["ostra_prove.js", "ostra_prove_bg.wasm"];
     PAD_INDEXER_URL = "https://app.ostraagent.xyz";
     ETHEREUM_PUBLIC_RPC = "https://ethereum-rpc.publicnode.com";
+    DEFAULT_SWAP_ANSWER_MS = 4e4;
   }
 });
 
 // src/tools.ts
+import { randomBytes as randomBytes6 } from "node:crypto";
 import { readFile as readFile6, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 import { z } from "zod";
@@ -34445,7 +34734,79 @@ function registerTools(server, agent) {
     return agent.privateBalance;
   };
   const opt = (key, value) => value === void 0 ? {} : { [key]: value };
-  const tool = (name, description, shape, fn) => CLOSED_LAUNCHPAD_TOOLS.has(name) ? void 0 : server.registerTool(name, { description, inputSchema: shape }, ((args) => run2(() => fn(args), [agent.config.rpcUrl, agent.config.logsRpcUrl, ...agent.config.ethRpcUrl === null ? [] : [agent.config.ethRpcUrl]])));
+  const rpcUrls2 = [agent.config.rpcUrl, agent.config.logsRpcUrl, ...agent.config.ethRpcUrl === null ? [] : [agent.config.ethRpcUrl]];
+  const tool = (name, description, shape, fn) => CLOSED_LAUNCHPAD_TOOLS.has(name) ? void 0 : server.registerTool(name, { description, inputSchema: shape }, ((args) => run2(() => fn(args), rpcUrls2)));
+  const answerMs = agent.config.swapAnswerMs;
+  const swaps = /* @__PURE__ */ new Map();
+  const swapView = (r) => ({
+    swap: r.id,
+    what: r.what,
+    tokenIn: r.tokenIn,
+    tokenOut: r.tokenOut,
+    amount: r.amount,
+    startedAt: new Date(r.startedAt).toISOString(),
+    state: r.endedAt === void 0 ? "running" : r.error === void 0 ? "ended" : "failed",
+    // False while its call still waits for it (a client that gave up on that call learns the result here).
+    answeredPending: r.answered,
+    ...r.order === void 0 ? {} : { order: r.order },
+    ...r.split === void 0 ? {} : { split: r.split },
+    ...r.endedAt === void 0 ? {} : { endedAt: new Date(r.endedAt).toISOString() },
+    ...r.result === void 0 ? {} : { result: r.result },
+    ...r.error === void 0 ? {} : { error: r.error }
+  });
+  const boundedSwap = async (a, start) => {
+    const busy = [...swaps.values()].find((x) => x.endedAt === void 0 && x.tokenIn.toLowerCase() === a.tokenIn.toLowerCase());
+    if (busy !== void 0) {
+      throw new Error(`a swap from the agent's vault of ${a.tokenIn} is still running (${busy.what} of ${busy.amount}, begun ${new Date(busy.startedAt).toISOString()}): nothing was signed for this call; ostra_swap_orders shows how that one ends, call again once it has`);
+    }
+    const r = { id: randomBytes6(8).toString("hex"), ...a, startedAt: Date.now(), answered: false };
+    swaps.set(r.id, r);
+    const work = Promise.resolve().then(() => start({
+      onOrder: async (order) => {
+        r.order = order;
+      },
+      onSplit: async (id) => {
+        r.split = id;
+      }
+    }));
+    let timer;
+    const late = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(null), answerMs);
+    });
+    let first;
+    try {
+      first = await Promise.race([work.then((value) => ({ value })), late]);
+    } catch (err) {
+      swaps.delete(r.id);
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (first !== null) {
+      swaps.delete(r.id);
+      return first.value;
+    }
+    r.answered = true;
+    work.then(
+      (value) => {
+        r.result = value;
+        r.endedAt = Date.now();
+      },
+      (err) => {
+        r.error = rpcUrls2.reduce((text3, url) => redact(text3, url), err instanceof Error ? err.message : String(err));
+        r.endedAt = Date.now();
+      }
+    );
+    const ended = [...swaps.values()].filter((x) => x.endedAt !== void 0).sort((x, y) => x.endedAt - y.endedAt);
+    for (const x of ended.slice(0, Math.max(0, ended.length - ENDED_SWAPS_KEPT))) swaps.delete(x.id);
+    return {
+      status: "pending",
+      swap: r.id,
+      order: r.order ?? null,
+      split: r.split ?? null,
+      note: `${a.what} is still running after ${answerMs / 1e3} s and goes on in the MCP server: do not send it again. ostra_swap_orders shows how it ends (swap ${r.id}${r.order === void 0 ? "" : `, order ${r.order}`}${r.split === void 0 ? "" : `; split swap ${r.split}: ostra_swap_split list`}).`
+    };
+  };
   tool("open_vault", "Creates the agent's vault (USDG on Robinhood Chain, post-quantum WOTS keys) or finds it. With the Ostra relayer, its creation is paid later from the vault.", {}, () => agent.buyer.open());
   tool("balance", "The vault's balance, nonce, any operation signed and not landed, the relayer channels, and the creator vault.", {}, async () => ({
     vault: await agent.buyer.status(),
@@ -34539,9 +34900,27 @@ function registerTools(server, agent) {
   );
   tool(
     "ostra_swap",
-    "Swaps on Ostra Swap from the agent's vault of tokenIn to its vault of tokenOut, as an escrow order of OstraRouter: the vault signs one transfer into the order's escrow and the relayer executes it in the same transaction. The router pays at least minOut or sends the input back; where the tokens go is fixed by the escrow's address. A swap that moves the price more than maxImpactBps (default 1%) is split into up to 16 parts 60 seconds apart, each its own escrow order quoted again right before it is signed: a part waits while it would move the price more than the limit or pay less than the first part's quote less the slippage. The first part runs now and the next ones while the MCP server runs (ostra_swap_split); what is not swapped by the deadline stays in the vault.",
+    `Swaps on Ostra Swap from the agent's vault of tokenIn to its vault of tokenOut, as an escrow order of OstraRouter: the vault signs one transfer into the order's escrow and the relayer executes it in the same transaction. The router pays at least minOut or sends the input back; where the tokens go is fixed by the escrow's address. A swap that moves the price more than maxImpactBps (default 1%) is split into up to 16 parts 60 seconds apart, each its own escrow order quoted again right before it is signed: a part waits while it would move the price more than the limit or pay less than the first part's quote less the slippage. The first part runs now and the next ones while the MCP server runs (ostra_swap_split); what is not swapped by the deadline stays in the vault. A swap not done within ${answerMs / 1e3} s answers status "pending" and goes on: do not send it again; ostra_swap_orders tells how it ended.`,
     { tokenIn: swapToken, tokenOut: swapToken, amount: units.describe("in tokenIn"), slippageBps: slippage2, maxImpactBps: maxImpact },
-    (a) => ostraSwap().swap({ tokenIn: tokenAddress(a.tokenIn), tokenOut: tokenAddress(a.tokenOut), amount: a.amount, ...opt("slippageBps", a.slippageBps), ...opt("maxImpactBps", a.maxImpactBps) })
+    (a) => {
+      const tokenIn = tokenAddress(a.tokenIn);
+      const tokenOut = tokenAddress(a.tokenOut);
+      return boundedSwap(
+        { what: "the swap", tokenIn, tokenOut, amount: a.amount },
+        (hooks) => ostraSwap().swap({ tokenIn, tokenOut, amount: a.amount, ...opt("slippageBps", a.slippageBps), ...opt("maxImpactBps", a.maxImpactBps) }, hooks)
+      );
+    }
+  );
+  tool(
+    "ostra_swap_orders",
+    "The agent's Ostra Swap orders: swaps of this MCP server still running (their call waiting, or answered pending) and those that answered pending and then ended or failed, orders kept and not finished (signed or about to be, or landed and being finished by the MCP server's sweep each minute), and the last finished ones with what they spent and paid (refusal: why one did not swap, its input back in the vault). order: that order alone. Nothing is signed.",
+    { order: bytes323.optional() },
+    async (a) => {
+      const kept = await ostraSwap().orders(a.order === void 0 ? {} : { order: a.order });
+      const want = a.order?.toLowerCase();
+      const pending = [...swaps.values()].filter((x) => want === void 0 || x.order?.toLowerCase() === want).sort((x, y) => y.startedAt - x.startedAt);
+      return { pending: pending.map(swapView), open: kept.open, finished: kept.finished };
+    }
   );
   tool(
     "ostra_swap_split",
@@ -34706,7 +35085,7 @@ function registerTools(server, agent) {
   const earnings = z.record(z.string().regex(/^[A-Z]{1,8}$/), z.number().int().min(0)).optional().describe("earnings dates the agent knows, unix seconds by stock ticker (without one NVDA stays at most 60% of its LLTV)");
   tool(
     "strategy_plan",
-    "Plans what the agent's vaults hold, computed from the chain now: a conservative plan (USDG into a cash vault that passes every check of Strategy 1) and, when a carry of the agent's SPY, QQQ or NVDA may open, a balanced one (Strategy 2: the stock lent to Borro as collateral, USDG borrowed into the cash vault), each with its steps, gas, what it earns in 30 days net of gas, risks, when it stops, and whether OstraBreaker watches (Strategy 3). Every step earns over 3x its gas in 30 days or is left out. The trading capital's cash (trading) stays in the vault. Nothing is signed. Only for an agent registered in ERC-8004 (register_agent).",
+    "Plans what the agent's vaults hold, computed from the chain now: a conservative plan (USDG into a cash vault that passes every check of Strategy 1) and, when a carry of the agent's SPY, QQQ or NVDA may open, a balanced one (Strategy 2: the stock lent to Borro as collateral, USDG borrowed into the cash vault), each with its steps, gas, what it earns in 30 days net of gas, risks, when it stops, and whether OstraBreaker watches (Strategy 3). Every step earns over 3x its gas in 30 days or is left out. The trading capital's cash (trading) stays in the vault. Nothing is signed. Only for an agent registered in ERC-8004 (publish_profile).",
     { buffer: usdg.optional().describe("USDG kept for payments (default: what the vault spent over 7 days)"), earnings },
     (a) => agent.strategy.plan({
       ...a.buffer === void 0 ? {} : { buffer: parseUsdg(a.buffer) },
@@ -34728,7 +35107,7 @@ function registerTools(server, agent) {
   const bpsLimit = z.number().int().min(1).max(1e4).optional();
   tool(
     "trading",
-    `The trading capital: USDG of the vault set aside for trades the agent decides, with Ostra's limits (an agent may only tighten them): a position at most 25% of the capital (positionMaxBps) and no larger than a buy whose quote moves the price 1% (maxImpactBps); buys stop for the day after a 5% loss of the capital that day (dailyLossBps) and for the week after 10% that week (weeklyLossBps). set: sets it (capital in USDG, the limits), only with no position open; the plans keep its cash out of the cash vaults. status: its value now (cash, positions at the quote of selling them), whether buys may happen and, with token, the most that position may be. buy: buys token with amount USDG of the capital, refused past those limits. sell: sells amount (or "all") of the capital's token, split like any large swap. end: ends it (positions stay in their vaults, untracked). Trades go through Ostra Swap; only for an agent registered in ERC-8004 (register_agent) to set it or buy.`,
+    `The trading capital: USDG of the vault set aside for trades the agent decides, with Ostra's limits (an agent may only tighten them): a position at most 25% of the capital (positionMaxBps) and no larger than a buy whose quote moves the price 1% (maxImpactBps); buys stop for the day after a 5% loss of the capital that day (dailyLossBps) and for the week after 10% that week (weeklyLossBps). set: sets it (capital in USDG, the limits), only with no position open; the plans keep its cash out of the cash vaults. status: its value now (cash, positions at the quote of selling them), whether buys may happen and, with token, the most that position may be. buy: buys token with amount USDG of the capital, refused past those limits. sell: sells amount (or "all") of the capital's token, split like any large swap. A buy or sell not done in time (${agent.config.swapAnswerMs / 1e3} s) answers status "pending" and goes on: do not send it again; ostra_swap_orders tells how it ended. end: ends it (positions stay in their vaults, untracked). Trades go through Ostra Swap; only for an agent registered in ERC-8004 (publish_profile) to set it or buy.`,
     {
       action: z.enum(["set", "status", "buy", "sell", "end"]),
       capital: usdg.optional(),
@@ -34758,9 +35137,11 @@ function registerTools(server, agent) {
       const token = tokenAddress(a.token);
       if (a.action === "buy") {
         if (a.amount === "all") throw new RangeError("buy takes an amount of USDG");
-        return t.buy({ token, amount: a.amount, ...opt("slippageBps", a.slippageBps) });
+        const amount2 = a.amount;
+        return boundedSwap({ what: "the trading buy", tokenIn: USDG, tokenOut: token, amount: amount2 }, () => t.buy({ token, amount: amount2, ...opt("slippageBps", a.slippageBps) }));
       }
-      return t.sell({ token, amount: a.amount, ...opt("slippageBps", a.slippageBps) });
+      const amount = a.amount;
+      return boundedSwap({ what: "the trading sell", tokenIn: token, tokenOut: USDG, amount }, () => t.sell({ token, amount, ...opt("slippageBps", a.slippageBps) }));
     }
   );
   tool("strategy_report", "What the strategies earn: yield per day by route at the rates now, the share growth since the first run that held each cash vault, and each carry's distance to liquidation.", {}, () => agent.strategy.report());
@@ -34829,7 +35210,7 @@ function registerTools(server, agent) {
   const files = z.array(z.string().max(200).regex(/^ipfs:\/\/[A-Za-z0-9]+(\/[A-Za-z0-9._-]+)*$/)).max(10).optional().describe("ipfs:// files (upload_image makes one)");
   tool(
     "pad_publish",
-    "Ostrapad as a provider. publish: lists offers in the agent's ERC-8004 registration file, paid into its USDG vault (the vault approves the listing once, so a listing is its own); needs publish_profile and register_agent first, and USDG in the creator vault for its relayed transactions (checked before the approval). unpublish: removes the listing. status: the agent's own listing as clients read it. bond / withdraw_bond: a voluntary provider bond (raises the limit per job to the bond, up to 500 USDG; a rejected job costs it 10% of the budget plus the evaluator fee). return_bond_box: returns USDG left in the provider bond box (a deposit whose second step failed) to the USDG vault.",
+    "Ostrapad as a provider. publish: lists offers in the agent's ERC-8004 registration file, paid into its USDG vault (the vault approves the listing once, so a listing is its own); needs publish_profile first (it registers the agent), and USDG in the creator vault for its relayed transactions (checked before the approval). unpublish: removes the listing. status: the agent's own listing as clients read it. bond / withdraw_bond: a voluntary provider bond (raises the limit per job to the bond, up to 500 USDG; a rejected job costs it 10% of the budget plus the evaluator fee). return_bond_box: returns USDG left in the provider bond box (a deposit whose second step failed) to the USDG vault.",
     { action: z.enum(["publish", "unpublish", "status", "bond", "withdraw_bond", "return_bond_box"]), offers: z.array(offer).min(1).max(20).optional(), amount: usdg.optional() },
     async (a) => {
       if (a.action === "publish") {
@@ -34979,17 +35360,9 @@ function registerTools(server, agent) {
     (a) => lp().tokenInfo(a.token)
   );
   tool("profile", "The agent's public identity, its creator vault: the profile URI it set, that profile read from IPFS, and its ERC-8004 agent id; or another account's profile.", { account: address5.optional() }, (a) => lp().profile(a.account));
-  tool(
-    "set_profile",
-    "Sets the agent's profile in OstraRegistry from its creator vault, with a WOTS-signed spend: uri is an ipfs:// (or https://) JSON file with name, description, image and links, ideally an ERC-8004 registration file.",
-    { uri },
-    (a) => lp().setProfile(a.uri)
-  );
-  tool("register_agent", "Registers the agent in the ERC-8004 Identity Registry, once: its creator vault owns the identity and is its agentWallet; uri is its ERC-8004 registration file.", { uri }, (a) => lp().registerAgent(a.uri));
-  tool("set_agent_uri", "Points the agent's ERC-8004 identity at a new registration file.", { uri }, (a) => lp().setAgentUri(a.uri));
   tool(
     "upload_image",
-    `Pins an image file on this machine (PNG, JPEG, WebP or GIF, at most ${MAX_UPLOAD_IMAGE_BYTES} bytes) to IPFS through the Ostra uploader and returns its ipfs:// URI, for a profile or a token's metadata.`,
+    `Pins an image file on this machine (PNG, JPEG, WebP or GIF, at most ${MAX_UPLOAD_IMAGE_BYTES} bytes) to IPFS through the Ostra uploader and returns its ipfs:// URI, for the files of an Ostrapad order or delivery.`,
     { path: z.string().min(1).max(4096) },
     async (a) => {
       const s = await stat4(a.path);
@@ -34999,9 +35372,9 @@ function registerTools(server, agent) {
   );
   tool(
     "publish_profile",
-    "Publishes the agent's profile: builds its ERC-8004 registration file (name, description, image, links, its creator vault as agentWallet), pins it to IPFS, sets it in OstraRegistry and, once the agent is registered, points its ERC-8004 identity at it.",
-    { name: z.string().min(1).max(64), ...publicFields },
-    (a) => lp().publishProfile(a)
+    `Publishes the agent's Ostra profile and registers it in the ERC-8004 Identity Registry, with nothing to fill in: the same for every Ostra agent ("Ostra Agent #<id>", Ostra's description, the Ostra agent card as its image, its creator vault as agentWallet). The first call publishes the profile, registers the agent (its creator vault owns the identity) and publishes the profile again with the agent's number; a later call publishes it again (an Ostrapad listing in it is kept). Needs USDG in the creator vault (fund_creator_vault).`,
+    {},
+    () => lp().publishProfile()
   );
   tool(
     "publish_token_metadata",
@@ -35064,7 +35437,7 @@ function launchOptions(raw) {
   }
   return out;
 }
-var toJson, address5, usdg, units, pair2, slippage2, bytes323, maxImpact, swapToken, tokenAddress, uri, publicFields, AI_DIR, MAX_VIDEO_BYTES, FINAL_JOB, CLOSED_LAUNCHPAD_TOOLS, BIGINT_FIELDS, ALLOWED_OPTIONS;
+var toJson, address5, usdg, units, pair2, slippage2, bytes323, maxImpact, swapToken, tokenAddress, uri, publicFields, AI_DIR, MAX_VIDEO_BYTES, FINAL_JOB, CLOSED_LAUNCHPAD_TOOLS, ENDED_SWAPS_KEPT, BIGINT_FIELDS, ALLOWED_OPTIONS;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
@@ -35117,6 +35490,7 @@ var init_tools = __esm({
       "airdrop_fund",
       "airdrop_start"
     ]);
+    ENDED_SWAPS_KEPT = 20;
     BIGINT_FIELDS = /* @__PURE__ */ new Set(["minDividendBalance", "maxBuy", "maxWallet", "graduationThreshold"]);
     ALLOWED_OPTIONS = /* @__PURE__ */ new Set([
       "tiers",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ostraagent/mcp",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Ostra Agent's MCP server (stdio): the post-quantum privacy vault for AI agents. One vault to pay, earn, work and hire on Ostrapad, and stay private on Robinhood Chain, with no ETH (the Ostra relayer sends its transactions, paid in USDG).",
   "keywords": [
     "mcp",