@ostraagent/mcp 0.1.10 → 0.1.11

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.10", 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.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" };
   }
 });
 
@@ -15521,6 +15521,7 @@ async function readBorroPosition(client, stockVault, stock2) {
     listed,
     supply: e.totalSupplyAssets,
     borrowed: e.totalBorrowAssets,
+    borrowedShares: e.totalBorrowShares,
     at: at.timestamp
   };
 }
@@ -20248,6 +20249,10 @@ import { decodeFunctionData as decodeFunctionData4, getAddress as getAddress17,
 import { x402Client, x402HTTPClient } from "@x402/core/client";
 import { toClientEvmSigner } from "@x402/evm";
 import { BatchSettlementEvmScheme } from "@x402/evm/batch-settlement/client";
+function notLandedError(attempts, lastReason) {
+  const reason = lastReason.trim().slice(0, NOT_SENT_MESSAGE_MAX);
+  return new Error(`the relayer could not land the request in ${attempts} attempts${reason === "" ? "" : `; it answered last: ${reason}`}`);
+}
 function address(value, what) {
   if (typeof value !== "string" || !isAddress6(value, { strict: false })) throw new Error(`${what} is not an address`);
   return getAddress17(value);
@@ -20296,6 +20301,25 @@ function relayerChannelDeposit(needed, vaultBalance, keep = 0n) {
   const want = needed > RELAYER_CHANNEL_DEPOSIT ? needed : RELAYER_CHANNEL_DEPOSIT;
   return want < available ? want : available;
 }
+function relayerSpendPlan(p) {
+  const rooms = [...p.rooms];
+  let balance = p.balance;
+  let debt = p.debt;
+  for (const a of p.amounts) {
+    const i = debt > 0n ? -1 : rooms.findIndex((r) => r >= a);
+    if (i >= 0) {
+      rooms[i] = rooms[i] - a;
+      continue;
+    }
+    const needed = debt + p.openCost + a;
+    if (balance < needed) return false;
+    const deposit = relayerChannelDeposit(needed, balance);
+    balance -= deposit;
+    debt = 0n;
+    rooms.push(deposit - needed);
+  }
+  return true;
+}
 function relayerOfferProblem(r, want) {
   if (r.scheme !== "batch-settlement") return `the offer is ${r.scheme}, not batch-settlement`;
   if (r.network !== want.network) return `the offer is on ${r.network}, not ${want.network}`;
@@ -20330,7 +20354,7 @@ function openChannelCall(calls, vault, token) {
   }
   return null;
 }
-var RELAYER_DIR, VAULT_SPEND_GAS, REQUEST_TIMEOUT_MS2, MAX_STEPS, MAX_RESENDS, LANDED_TIMEOUT_MS, OPEN_READ_TRIES, OPEN_READ_INTERVAL_MS, BPS_DENOMINATOR, now, LocalSender, RelayerUnavailableError, PendingSpendUnpaidError, RelayerError, RelayerStore, RelayerClient;
+var RELAYER_DIR, VAULT_SPEND_GAS, REQUEST_TIMEOUT_MS2, MAX_STEPS, MAX_RESENDS, NOT_SENT_MESSAGE_MAX, LANDED_TIMEOUT_MS, OPEN_READ_TRIES, OPEN_READ_INTERVAL_MS, BPS_DENOMINATOR, now, LocalSender, RelayerUnavailableError, PendingSpendUnpaidError, RelayerError, RelayerStore, RelayerClient;
 var init_relay = __esm({
   "../core/src/relay.ts"() {
     "use strict";
@@ -20344,6 +20368,7 @@ var init_relay = __esm({
     REQUEST_TIMEOUT_MS2 = 24e4;
     MAX_STEPS = 8;
     MAX_RESENDS = 3;
+    NOT_SENT_MESSAGE_MAX = 500;
     LANDED_TIMEOUT_MS = 6e4;
     OPEN_READ_TRIES = 20;
     OPEN_READ_INTERVAL_MS = 500;
@@ -20572,6 +20597,55 @@ var init_relay = __esm({
         }
         return null;
       }
+      /**
+       * Read only (nothing is retired, opened or signed): why this vault cannot pay, now, vault spends that reserve `gases`
+       * (each as VaultService.operate reserves it: reserve's amount for that gas), or null when it can. The spends are
+       * played in order as reserve and #ensureChannel would pay them: each from a usable relayer channel with room for it,
+       * or else from a new channel, whose open needs the vault's debt and the open's own spend (#spendBound) on top and
+       * takes RELAYER_CHANNEL_DEPOSIT or what it needs, at most what the vault holds. The vault's credit at the relayer is
+       * not counted: it lowers a price only after the reservation is made. An unpaid open the relayer holds for the vault
+       * is refused here (it is paid before anything else). An operation that sends something first (an approval before the
+       * call it allows) checks this before its first spend, so it does not leave the first done and the rest unpaid.
+       */
+      async shortfall(gases) {
+        const facts = await this.facts();
+        const vault = await this.#buyerVault().vaultAddress();
+        if (await readVault(this.#client, this.#config.deployment, vault) === null) return `the vault ${vault} does not exist yet`;
+        const state = await this.vaultState(vault);
+        if (state.unpaidOpen !== null) return `the relayer holds an unpaid open of the vault's relayer channel ${state.unpaidOpen.channel}: the vault's next relayed operation pays it first`;
+        const amounts = [];
+        for (const g of gases) amounts.push(await this.#reserveAmount(g));
+        const bound2 = await this.#spendBound();
+        const payer = await this.#payer();
+        const rooms = [];
+        for (const c of await this.#records()) {
+          if (c.retired || now() >= c.openedAt + SESSION_MAX_AGE_SECONDS) continue;
+          const free = this.#free(c, null);
+          if (free <= 0n) continue;
+          const ch = await readChannel(this.#client, this.#config.deployment.batchSettlement, c.channel);
+          const usable = payer !== null && getAddress17(c.config.payer) === payer && getAddress17(c.config.receiverAuthorizer) === facts.vault && getAddress17(c.config.receiver) === facts.split && ch.pendingWithdrawal === null;
+          const onChain = ch.balance - BigInt(c.cumulative);
+          if (usable) rooms.push(free < onChain ? free : onChain);
+        }
+        const balance = await tokenBalance(this.#client, this.#config.deployment.token, vault);
+        const plan = (held) => relayerSpendPlan({ amounts, rooms, balance: held, debt: state.debt, openCost: bound2 });
+        if (plan(balance)) return null;
+        let lo = balance;
+        let hi = balance > 0n ? balance * 2n : 1n;
+        while (!plan(hi)) hi *= 2n;
+        while (hi - lo > 1n) {
+          const mid = (lo + hi) / 2n;
+          if (plan(mid)) hi = mid;
+          else lo = mid;
+        }
+        const n = gases.length;
+        return `the vault ${vault} holds ${formatTokenAmount(balance)} USDG: ${n === 1 ? "its relayed transaction needs" : `its ${n} relayed transactions need`} it to hold ${formatTokenAmount(hi)} USDG now (with what its relayer channels have left, and a new channel's open where needed)`;
+      }
+      /** What reserve sets aside for a spend of `gas` (and `extraWei` of ETH it sends): the relayer's price for it, margin and tolerance included. */
+      async #reserveAmount(gas, extraWei = 0n) {
+        const wei = withMargin(gas * await this.#client.getGasPrice()) + extraWei;
+        return maxAcceptedQuote(weiToTokenUnits(wei, await this.#ethUsd(), TOKEN_DECIMALS));
+      }
       /** Base units a transaction of `wei` comes to at the Chainlink price, margin included (the relayer's rule). */
       async #amountFor(wei) {
         return weiToTokenUnits(withMargin(wei), await this.#ethUsd(), TOKEN_DECIMALS);
@@ -20610,8 +20684,7 @@ var init_relay = __esm({
         await (openChannel ?? ((t) => this.#buyerVault().openRelayerChannel(t)))(terms);
       }
       async reserve(gas, openChannel, keep = 0n, extraWei = 0n) {
-        const wei = withMargin(gas * await this.#client.getGasPrice()) + extraWei;
-        const amount = maxAcceptedQuote(weiToTokenUnits(wei, await this.#ethUsd(), TOKEN_DECIMALS));
+        const amount = await this.#reserveAmount(gas, extraWei);
         for (let attempt = 0; attempt < 2; attempt++) {
           const c = await this.#serial(async () => {
             const found = await this.#channelFor(amount, null);
@@ -20826,6 +20899,7 @@ var init_relay = __esm({
       }
       async send(calls, options = {}) {
         await this.facts();
+        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 again = false;
@@ -20848,6 +20922,7 @@ var init_relay = __esm({
               continue;
             }
             if (answer.status === 409 && error === "not_sent") {
+              notSent = typeof b?.message === "string" ? b.message : "";
               again = true;
               continue;
             }
@@ -20866,7 +20941,7 @@ var init_relay = __esm({
           }
           if (!again) throw new Error(`the relayer did not relay the request after ${MAX_STEPS} answers`);
         }
-        throw new Error(`the relayer could not land the request in ${MAX_RESENDS} attempts`);
+        throw notLandedError(MAX_RESENDS, notSent);
       }
       /**
        * Relayer channels past SESSION_MAX_AGE_SECONDS stop paying; returns those
@@ -22035,6 +22110,21 @@ var init_borro2 = __esm({
         }
         return { buyerVault: buyer, usdgLent: { shares: usdg2.shares.toString(), value: formatUnitsAmount(usdg2.value, TOKEN_DECIMALS) }, stocks };
       }
+      /**
+       * Per Borro stock whose vault of this agent exists: its market, the stock vault's borrow shares, and the market's
+       * borrows and borrow shares accrued to this block, so that any number of borrow shares is valued now as
+       * toAssetsUp(shares, borrowed, borrowedShares) (what fundFromYield takes off as the debt's interest).
+       */
+      async debtBook() {
+        const out = [];
+        for (const s of borroStocks()) {
+          const v = await this.#p.tokenVault(s.token).vaultAddress();
+          if (await readVault(this.#p.client, this.#p.config.deployment, v) === null) continue;
+          const p = await readBorroPosition(this.#p.client, v, s);
+          out.push({ symbol: s.symbol, marketId: s.marketId, borrowShares: p.borrowShares, borrowed: p.borrowed, borrowedShares: p.borrowedShares });
+        }
+        return out;
+      }
       // -------------------------------------------------------------------------
       // Lend and redeem
       // -------------------------------------------------------------------------
@@ -23562,7 +23652,7 @@ function simulatedGas(gasUsed) {
   const g = gasUsed * 5n / 4n + SPEND_GAS_HEADROOM2;
   return g > VAULT_SPEND_GAS ? g : VAULT_SPEND_GAS;
 }
-var LAUNCHPAD_DIR, CREATE_VAULT_GAS2, LAUNCH_GAS_HEADROOM, PAIRS_READ_CONCURRENCY, SPEND_GAS_HEADROOM2, DAY, TOKEN_LIST_MAX, METADATA_MAX_BYTES, launchedEvent, POOL_SETTING_NAMES, LaunchpadService;
+var LAUNCHPAD_DIR, CREATE_VAULT_GAS2, LAUNCH_GAS_HEADROOM, PAIRS_READ_CONCURRENCY, SPEND_GAS_HEADROOM2, DAY, TOKEN_LIST_MAX, METADATA_MAX_BYTES, launchedEvent, POOL_SETTING_NAMES, WOTS_GAS_SPREAD, STAND_IN_URI, LaunchpadService;
 var init_launchpad = __esm({
   "../core/src/launchpad.ts"() {
     "use strict";
@@ -23598,6 +23688,8 @@ var init_launchpad = __esm({
       volatility_fee: POOL_SETTING.VOLATILITY_FEE,
       max_tx_move: POOL_SETTING.MAX_TX_MOVE
     };
+    WOTS_GAS_SPREAD = 100000n;
+    STAND_IN_URI = `ipfs://bafkrei${"a".repeat(52)}`;
     LaunchpadService = class {
       #client;
       #transport;
@@ -24503,6 +24595,32 @@ var init_launchpad = __esm({
         if (profile.status !== "sent" || record === null) return { uri: uri2, profile, agentUri: null, pairCreators };
         return { uri: uri2, profile, agentUri: await this.setAgentUri(uri2), pairCreators };
       }
+      /**
+       * Read only: why the creator vault cannot pay for publishRegistrationFile now, or null when it can or does not pay
+       * through the relayer. Its spends (the profile and, once the agent is registered, its agent URI) are simulated as
+       * setProfile and setAgentUri send them, with the URI set now (or one of an ipfs:// URI's length) in place of the
+       * file's, and each is counted at the gas it will be reserved (simulatedGas) with WOTS_GAS_SPREAD added (a simulation
+       * signs with a throwaway key, and a WOTS signature's verification costs more or less with each message);
+       * RelayerClient.shortfall replays their payment. A
+       * spend the creator vault signed earlier and has not sent is refused here: its next operation would send that one
+       * instead of the profile.
+       */
+      async publishShortfall() {
+        if (!(this.#creatorSender instanceof RelayerClient)) return null;
+        const s = await this.#creator.state();
+        if (!s.exists) return `the creator vault ${s.vault} does not exist yet`;
+        if ((await this.#creator.spendSlot())?.pending != null) {
+          return `the creator vault ${s.vault} signed a spend earlier that has not landed: its next operation sends that one first (publish_profile with the same fields does), then publish again`;
+        }
+        const record = await this.#agentRecord();
+        const uri2 = record?.uri ?? await this.#profileUri(s.vault) ?? STAND_IN_URI;
+        const relayer = await this.#creatorSender.payer();
+        const gasOf = async (action, params) => simulatedGas((await simulateVaultSpend(this.#client, this.#config.deployment, { relayer, vault: s.vault, action, params })).gasUsed + WOTS_GAS_SPREAD);
+        const gases = [await gasOf(VAULT_ACTION.SET_PROFILE, setProfileParams(uri2))];
+        if (record !== null) gases.push(await gasOf(VAULT_ACTION.SET_AGENT_URI, setAgentUriParams({ agentId: BigInt(record.agentId), uri: uri2 })));
+        const short = await this.#creatorSender.shortfall(gases);
+        return short === null ? null : `${short}; fund_creator_vault moves USDG into it`;
+      }
       /**
        * Pins `file`, a registration file built from the current one (Ostrapad's listing, pad.ts), and makes it the
        * agent's profile in OstraRegistry and its ERC-8004 registration file when it is registered.
@@ -24818,7 +24936,11 @@ var init_pad2 = __esm({
           if (offers !== null) {
             const entry = padServiceEntry({ provider: vault, offers }, this.#pad, this.#p.config.chainId);
             const digest = padListingDigest(agentId, creatorVault, this.#pad, this.#p.config.chainId);
-            if (!await this.#approved(vault, digest)) approval = await this.#approveAlone(digest, "Ostrapad listing approval");
+            if (!await this.#approved(vault, digest)) {
+              const short = this.#p.publishShortfall === void 0 ? null : await this.#p.publishShortfall();
+              if (short !== null) throw new Error(`the creator vault could not publish the listing now, so its approval is not given: ${short}; nothing was signed`);
+              approval = await this.#approveAlone(digest, "Ostrapad listing approval");
+            }
             services.push(entry);
           }
           const out = await this.#p.publishFile({ ...current, services });
@@ -25542,6 +25664,19 @@ var init_pay = __esm({
 
 // ../core/src/raeto.ts
 import { getAddress as getAddress27, hashMessage, isAddress as isAddress13, parseAbi as parseAbi6 } from "viem";
+function netYieldSince(mark, now3, book) {
+  if (mark.debts === void 0) return null;
+  const high = BigInt(mark.price);
+  const earned = now3.price > high ? BigInt(mark.shares) * (now3.price - high) / now3.unit : 0n;
+  let interest = 0n;
+  for (const d of mark.debts) {
+    const m = book.find((b) => b.marketId.toLowerCase() === d.marketId.toLowerCase());
+    if (m === void 0) return null;
+    const owesNow = toAssetsUp(BigInt(d.borrowShares), m.borrowed, m.borrowedShares);
+    if (owesNow > BigInt(d.debt)) interest += owesNow - BigInt(d.debt);
+  }
+  return { earned, interest };
+}
 function raetoImages(answer) {
   const out = [];
   const choices = answer?.choices;
@@ -25788,15 +25923,20 @@ var init_raeto = __esm({
         return this.#scrub(await this.#call("POST", "/v1/chat/completions", request, await this.#key(), COMPLETION_TIMEOUT_MS));
       }
       /**
-       * What the vault's cash vault shares earn, as credits. Kept here: a mark (the shares, and the highest share price read:
-       * a high-water mark, so a price that falls and comes back earns nothing until it passes its high), what is owed (the
-       * shares of each mark times the rise of the price over its high, added on every call), and USDG redeemed for it and
-       * not sent yet (`ready`), with the vault's spend slot its transfer is signed at. A call adds what the shares earned
-       * since the mark, moves the mark to now, sends what was redeemed and not sent first, and else, when what is owed is at
-       * least `min` USDG, redeems that from the cash vault and sends what the redeem paid (at most what is owed) to Raeto's
-       * payTo. A transfer of `ready` that another operation of the vault sent first (it sends a signed spend before its
-       * own) is found at its slot and not paid again. Shares added or removed count from the read after; a full exit leaves
-       * what was owed until then. Raeto's terms are checked before anything is redeemed. Calls run one after the other.
+       * What the vault's cash vault shares earn, net of the agent's Borro debts' interest, as credits. Kept here: a mark
+       * (the shares, the highest share price read: a high-water mark, so a price that falls and comes back earns nothing
+       * until it passes its high; and each Borro debt's borrow shares with what they owed), what is owed (netYieldSince,
+       * added on every call: the shares' rise over the high less the interest the marked debts accrued; it can fall below
+       * zero, and nothing is sent until it is back above `min`), and USDG redeemed for it and not sent yet (`ready`), with
+       * the vault's spend slot its transfer is signed at. The interest comes off because the carry strategy borrows USDG
+       * from Borro into this same cash vault: the shares' rise is not earned while the loan behind them owes interest.
+       * A call adds what was earned since the mark, moves the mark to now, sends what was redeemed and not sent first, and
+       * else, when what is owed is at least `min` USDG, redeems that from the cash vault and sends what the redeem paid (at
+       * most what is owed) to Raeto's payTo. A transfer of `ready` that another operation of the vault sent first (it sends
+       * a signed spend before its own) is found at its slot and not paid again. Shares and debts added or removed count
+       * from the read after; a full exit leaves what was owed until then. A mark kept before debts were marked (MCP 0.1.10
+       * and earlier) earns nothing for the time since it, as that time's interest cannot be read back. Raeto's terms are
+       * checked before anything is redeemed. Calls run one after the other.
        */
       fundFromYield(min2 = "1") {
         return this.#serial(async () => {
@@ -25810,20 +25950,25 @@ var init_raeto = __esm({
             return { shares, unit, price };
           };
           const now3 = await read();
+          const book = await this.#p.borro.debtBook();
+          const debts = book.filter((b) => b.borrowShares > 0n).map((b) => ({ marketId: b.marketId, borrowShares: b.borrowShares.toString(), debt: toAssetsUp(b.borrowShares, b.borrowed, b.borrowedShares).toString() }));
           const text3 = await this.#p.folder.read(YIELD_FILE);
           const kept = text3 === void 0 ? null : JSON.parse(text3);
-          const usd4 = (x) => formatUnitsAmount(x, TOKEN_DECIMALS);
+          const usd4 = (x) => formatUnitsAmount(x > 0n ? x : 0n, TOKEN_DECIMALS);
           const write = (m) => this.#p.folder.write(YIELD_FILE, JSON.stringify(m));
           if (kept === null || getAddress27(kept.vault) !== target) {
-            await write({ vault: target, shares: now3.shares.toString(), price: now3.price.toString(), owed: "0", ready: "0" });
-            return { vault: target, owed: "0", sent: "0", note: "the mark is set now: what the shares earn from here is sent as credits by later calls" };
+            await write({ vault: target, shares: now3.shares.toString(), price: now3.price.toString(), owed: "0", ready: "0", debts });
+            return { vault: target, owed: "0", sent: "0", note: "the mark is set now: what the shares earn from here, less the Borro debts' interest, is sent as credits by later calls" };
           }
           const high = BigInt(kept.price);
-          let owed = BigInt(kept.owed) + (now3.price > high ? BigInt(kept.shares) * (now3.price - high) / now3.unit : 0n);
+          const net = netYieldSince(kept, now3, book);
+          let owed = BigInt(kept.owed) + (net === null ? 0n : net.earned - net.interest);
           let ready = BigInt(kept.ready);
-          const mark = { ...kept, vault: target, shares: now3.shares.toString(), price: (now3.price > high ? now3.price : high).toString(), owed: owed.toString(), ready: ready.toString() };
+          const mark = { ...kept, vault: target, shares: now3.shares.toString(), price: (now3.price > high ? now3.price : high).toString(), owed: owed.toString(), ready: ready.toString(), debts };
           await write(mark);
-          if (ready === 0n && (owed === 0n || owed < minimum)) return { vault: target, owed: usd4(owed), sent: "0", note: `under ${min2} USDG: kept for a later call` };
+          const unmarked = net === null ? "the mark did not follow the Borro debts yet (kept by an earlier version): nothing is counted for the time since it, and the mark now follows them; " : "";
+          if (ready === 0n && owed < 0n) return { vault: target, owed: "0", sent: "0", note: `${unmarked}the Borro debts' interest since the mark is more than the shares earned: ${formatUnitsAmount(-owed, TOKEN_DECIMALS)} USDG to make up before anything is sent` };
+          if (ready === 0n && (owed === 0n || owed < minimum)) return { vault: target, owed: usd4(owed), sent: "0", note: `${unmarked}under ${min2} USDG: kept for a later call` };
           const { payTo } = await this.terms();
           if (ready > 0n && mark.readySlot !== void 0) {
             const slot2 = { nonce: BigInt(mark.readySlot.nonce), keyIndex: BigInt(mark.readySlot.keyIndex) };
@@ -25859,7 +26004,7 @@ var init_raeto = __esm({
             ready = paid <= 0n ? 0n : paid < owed ? paid : owed;
             owed -= ready;
             const afterHigh = BigInt(mark.price) > after.price ? BigInt(mark.price) : after.price;
-            await write({ vault: target, shares: after.shares.toString(), price: afterHigh.toString(), owed: owed.toString(), ready: ready.toString() });
+            await write({ vault: target, shares: after.shares.toString(), price: afterHigh.toString(), owed: owed.toString(), ready: ready.toString(), debts });
             if (ready === 0n) return { vault: target, owed: usd4(owed), sent: "0", note: "the redeem paid nothing into the vault", redeem };
           }
           const slot = await this.#p.buyer.spendSlot();
@@ -33955,6 +34100,7 @@ var init_agent = __esm({
             return typeof p2.profile === "object" && p2.profile !== null && !Array.isArray(p2.profile) ? p2.profile : null;
           },
           publishFile: (file) => lp.publishRegistrationFile(file),
+          publishShortfall: () => lp.publishShortfall(),
           upload: (file) => uploadJson(config.relayerUrl, file),
           indexerUrl: config.padIndexerUrl
         });
@@ -34624,7 +34770,7 @@ function registerTools(server, agent) {
   };
   tool(
     "raeto",
-    "Raeto (raeto.cc): 400+ AI models (text, and image models such as google/gemini-2.5-flash-image and openai/gpt-5-image-mini) through one OpenAI-compatible API, paid in Raeto credits of the vault's own Raeto account. login: signs the USDG vault in as an agent with EIP-1271 (the vault approves Raeto's login message, then withdraws the approval; refused under the withdrawal lock), its API key kept on this machine and never shown (name: the account's name; limitUsd: its spending limit). me: the account's credits. models: the models and prices per token (output: image for the image models). fund: sends `amount` USDG from the vault to Raeto, as credits. fund_yield: sends what the cash vault shares earned since the last call (at least `min`, default 1 USDG), redeemed then sent. complete: a model call, `request` in the OpenAI chat format with Raeto's model id (images it returns are saved as files in the agent's directory).",
+    "Raeto (raeto.cc): 400+ AI models (text, and image models such as google/gemini-2.5-flash-image and openai/gpt-5-image-mini) through one OpenAI-compatible API, paid in Raeto credits of the vault's own Raeto account. login: signs the USDG vault in as an agent with EIP-1271 (the vault approves Raeto's login message, then withdraws the approval; refused under the withdrawal lock), its API key kept on this machine and never shown (name: the account's name; limitUsd: its spending limit). me: the account's credits. models: the models and prices per token (output: image for the image models). fund: sends `amount` USDG from the vault to Raeto, as credits. fund_yield: sends what the cash vault shares earned since the last call, less the interest the agent's Borro loans accrued meanwhile (at least `min`, default 1 USDG), redeemed then sent. complete: a model call, `request` in the OpenAI chat format with Raeto's model id (images it returns are saved as files in the agent's directory).",
     {
       action: z.enum(["login", "me", "models", "fund", "fund_yield", "complete"]),
       name: z.string().min(1).max(64).optional(),
@@ -34683,7 +34829,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. 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 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.",
     { 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") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ostraagent/mcp",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "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",